{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0a7d9800",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cvxpy as cp\n",
    "import sklearn\n",
    "import sklearn.datasets\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "import gurobipy\n",
    "import mosek\n",
    "import matplotlib.pyplot as plt\n",
    "from multiprocessing import Pool\n",
    "import time\n",
    "import os\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "# My Code\n",
    "import LearningMethod as lm\n",
    "import DataGeneration as dg\n",
    "import LinearProgramMethod as lpm\n",
    "import OnlineMethod as om"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6b8dcf48",
   "metadata": {},
   "outputs": [],
   "source": [
    "focus = \"degree\"\n",
    "globals()[focus + \"_set\"] = [1]\n",
    "total_trial = 30\n",
    "methods = ['ExpRbf']\n",
    "for i in range(len(methods)):\n",
    "    globals()[f\"Loss_{methods[i]}\"] = np.zeros((total_trial, len(globals()[focus + \"_set\"])))\n",
    "    globals()[f\"Error_{methods[i]}\"] = np.zeros((total_trial, len(globals()[focus + \"_set\"])))\n",
    "    globals()[f\"Norm_Err_{methods[i]}\"] = np.zeros((total_trial, len(globals()[focus + \"_set\"])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "56a665b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate Fractional Knapsack Samples\n",
    "benchmark = 1\n",
    "dim_features = 5\n",
    "dim_decision = 10\n",
    "price = np.random.randint(low=1, high=1000, size=dim_decision)\n",
    "lower = np.amax(price)\n",
    "upper = (np.random.rand()-1)*lower + np.sum(price)\n",
    "Budget = [(upper-lower)*np.random.rand() + lower]\n",
    "Coeff_Mat = np.random.binomial(n=1, p=0.5, size = (dim_decision, dim_features))\n",
    "Theta_true = -np.concatenate((Coeff_Mat, np.zeros((dim_decision+1, dim_features))), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "110aabc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "N_train = 500\n",
    "# N_valid = 200\n",
    "N_test = 1000\n",
    "degree = 1\n",
    "additive_noise = 0.0\n",
    "scale_noise_uni = 0.0\n",
    "scale_noise_div = 0.0\n",
    "attack_threshold = None\n",
    "attack_power = 0.0\n",
    "z_train, c_train, A_train, b_train = dg.GenerateFractionalKnapsack(N_samples=N_train, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "                                    degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)\n",
    "# z_valid, c_valid, A_valid, b_valid = dg.GenerateFractionalKnapsack(N_samples=N_valid, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "#                                     degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)\n",
    "z_test, c_test, A_test, b_test = dg.GenerateFractionalKnapsack(N_samples=N_test, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "                                    degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e881583a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate Shortest Path Samples\n",
    "benchmark = 2\n",
    "dim_edge_vert = 4\n",
    "dim_edge_hori = 4\n",
    "dim_features = 6\n",
    "dim_cost = dim_edge_hori * (dim_edge_vert + 1) + (dim_edge_hori + 1) * dim_edge_vert\n",
    "Coeff_Mat = np.random.binomial(n=1, p=0.5, size = (dim_cost, dim_features))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2798ce9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "N_train = 200\n",
    "# N_valid = 200\n",
    "N_test = 1000\n",
    "degree = 4\n",
    "additive_noise = 0.0\n",
    "scale_noise_uni = 0.0\n",
    "scale_noise_div = 0.0\n",
    "attack_threshold = None\n",
    "attack_power = 0.0\n",
    "z_train, c_train, A_train, b_train = dg.GenerateShortestPath(N_samples = N_train, dim_features = dim_features, Coeff_Mat=Coeff_Mat,\n",
    "                                                            dim_edge_vert = dim_edge_vert, dim_edge_hori = dim_edge_hori,\n",
    "                                                            degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold=attack_threshold, attack_power=attack_power)\n",
    "# z_valid, c_valid, A_valid, b_valid = dg.GenerateShortestPath(N_samples = N_valid, dim_features = dim_features, Coeff_Mat=Coeff_Mat,\n",
    "#                                                             dim_edge_vert = dim_edge_vert, dim_edge_hori = dim_edge_hori,\n",
    "#                                                             degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold=attack_threshold, attack_power=attack_power)\n",
    "z_test, c_test, A_test, b_test = dg.GenerateShortestPath(N_samples = N_test, dim_features = dim_features, Coeff_Mat=Coeff_Mat,\n",
    "                                                            dim_edge_vert = dim_edge_vert, dim_edge_hori = dim_edge_hori,\n",
    "                                                            degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold=attack_threshold, attack_power=attack_power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7bddbbc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time cost 3.2414863109588623\n"
     ]
    }
   ],
   "source": [
    "# Compute Optimal Solutions\n",
    "start = time.time()\n",
    "basic_train, nonb_train, solution_train = lpm.ComputeBasis(c=c_train, A=A_train, b=b_train)\n",
    "#basic_valid, nonb_valid, solution_valid = lpm.ComputeBasis(c=c_valid, A=A_valid, b=b_valid)\n",
    "basic_test, nonb_test, solution_test = lpm.ComputeBasis(c=c_test, A=A_test, b=b_test)\n",
    "print(\"Time cost\", time.time() - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "98af1ea1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method Random Forest\n",
      "Training samples 1000\n",
      "Time Cost 0.38739728927612305\n",
      "Loss 0.21948659456220446 Error 0.49859117315434326 Normalized Error 0.49158763197470406\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tuning Hyperparameters\n",
    "# Random Forest\n",
    "# No Theta, directly predict c\n",
    "alg = 'RF'\n",
    "print(\"Method Random Forest\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "regr = RandomForestRegressor(random_state=0)\n",
    "regr.fit(z_train, c_train)\n",
    "hat_c = regr.predict(z_test)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark, A=A_test, b=b_test, c=c_test, z=z_test,\n",
    "                                                                                         direct=True, hat_c=hat_c, solved = True, solution=solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "981f0650",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method Ordinary Least Squares\n",
      "Training samples 1000\n",
      "Time Cost 3.307584762573242\n",
      "Loss 0.19415475388499986 Error 0.4533149522010404 Normalized Error 0.45179293804347115\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tuning Hyperparameters\n",
    "# Ordinary Least Squares\n",
    "alg = 'OLS'\n",
    "print(\"Method Ordinary Least Squares\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "globals()[\"Theta_\"+alg] = lm.OrdinaryLeastSquares(A = A_train, b = b_train, c = c_train, z = z_train)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = z_test, direct = False,\n",
    "                                                                                                Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "27618b67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method Ridge Regression\n",
      "Training samples 1000\n",
      "Time Cost 6.661448001861572\n",
      "Loss 0.15194116180577058 Error 0.22452946184714642 Normalized Error 0.04323134260851218\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tuning Hyperparameters\n",
    "# Ridge Regression\n",
    "alg = 'Ridge'\n",
    "print(\"Method Ridge Regression\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "globals()[\"Theta_\"+alg] = lm.RidgeRegression(A = A_train, b = b_train, c = c_train,  z = z_train, regular_const = 1e0)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = z_test, direct = False,\n",
    "                                                                                                Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5100885e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuning Hyperparameters\n",
    "# Margin Learning\n",
    "# Do not need true c\n",
    "# Do not need solution x but basis\n",
    "alg = 'ML'\n",
    "print(\"Method SVM Margin Learning\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "globals()[\"Theta_\"+alg] = lm.MarginLearning(A = A_train, b = b_train, z = z_train, basic = basic_train, nonb = nonb_train, \n",
    "                                            regular_const = 1e-2)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = z_test, direct = False,\n",
    "                                                                                                Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "289330b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method Poly-Kernelized SVM Margin Learning\n",
      "Training samples 500\n",
      "Time Cost 50.10742902755737\n",
      "Loss 0.003481790113631899 Error 2.385362348812643 Normalized Error 0.9626135449495582\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tuning Hyperparameters\n",
    "# Kernelized Margin Learning\n",
    "# Do not need true c\n",
    "# Do not need solution x but basis\n",
    "alg = 'PolyKer'\n",
    "ker_z_train = lm.PolyKernel(z = z_train, benchmark_z = z_train, gamma=1.0, degree=2, coef0=1.0)\n",
    "ker_z_test = lm.PolyKernel(z = z_test, benchmark_z = z_train, gamma=1.0, degree=2, coef0=1.0)\n",
    "print(\"Method Poly-Kernelized SVM Margin Learning\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "globals()[\"Theta_\"+alg] = lm.KernelizedMarginLearning(A = A_train, b = b_train, z = ker_z_train, basic = basic_train, nonb = nonb_train,\n",
    "                                                      regular_const=1e-1)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = ker_z_test, direct = False,\n",
    "                                                                                                Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "45f6c63c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method Rbf Kernelized SVM Margin Learning\n",
      "Training samples 500\n",
      "Time Cost 48.845229625701904\n",
      "Loss 0.001363436132815057 Error 4.356803827566979 Normalized Error 0.9613189211255628\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tuning Hyperparameters\n",
    "# Kernelized Margin Learning\n",
    "# Do not need true c\n",
    "# Do not need solution x but basis\n",
    "alg = 'ExpRbf'\n",
    "ker_z_train = lm.ExpKernel(z = z_train, benchmark_z = z_train, gamma=1e0)\n",
    "ker_z_test = lm.ExpKernel(z = z_test, benchmark_z = z_train, gamma=1e0)\n",
    "print(\"Method Rbf Kernelized SVM Margin Learning\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "globals()[\"Theta_\"+alg] = lm.KernelizedMarginLearning(A = A_train, b = b_train, z = ker_z_train, basic = basic_train, nonb = nonb_train,\n",
    "                                                      regular_const=1e-3)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = ker_z_test, direct = False,\n",
    "                                                                                                Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "de13a28d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method SPO+\n",
      "Training samples 1000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time Cost 73.65812611579895\n",
      "Loss 0.5987875151330696 Error 1.0007558631960765 Normalized Error 1.3691127547519202\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tuning Hyperparameters\n",
    "# SPO+\n",
    "alg = 'SPO'\n",
    "print(\"Method SPO+\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "globals()[\"Theta_\"+alg] = lm.SPOplus(A = A_train, b = b_train, c = c_train, z = z_train, \n",
    "                                     regular_const = 1e-4, step_size = 1e-1, batch_size = 5, max_iter = 1e3, \n",
    "                                     solved = True, solution = solution_train)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = z_test, direct = False,\n",
    "                                                                                                Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "53204ae2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method Naive OGD\n",
      "Training samples 500\n",
      "Time Cost 0.006976127624511719\n",
      "Loss 1.8388770292478134 Error 2.0838786030458283 Normalized Error 1.4042543516428285\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tuning Hyperparameters\n",
    "# Naive Online Gradient Descent\n",
    "# Do not need true c\n",
    "alg = 'NOGD'\n",
    "print(\"Method Naive OGD\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "globals()[\"Theta_\"+alg] = lm.NaiveOnlineGradientDescent(A = A_train, b = b_train, z = z_train, \n",
    "                                                        step_size = 1e-3, solution = solution_train, radius = 50)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = z_test, direct = False,\n",
    "                                                                                                Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5448e80f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method SVM OGD\n",
      "Training samples 1000\n",
      "Time Cost 0.0670003890991211\n",
      "Loss 0.38048191031371514 Error 0.9994669064078309 Normalized Error 1.3105632225268369\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tuning Hyperparameters\n",
    "# SVM Margin Online Gradient Descent\n",
    "# Do not need true c\n",
    "# Do not need solution x but basis\n",
    "alg = 'SVMOGD'\n",
    "print(\"Method SVM OGD\")\n",
    "print(\"Training samples\", N_train)\n",
    "start = time.time()\n",
    "globals()[\"Theta_\"+alg] = lm.SVM_OGD(A = A_train, b = b_train, z = z_train, basic = basic_train, nonb = nonb_train,\n",
    "                                     step_size = 1e-4, radius = 1.1* np.linalg.norm(Coeff_Mat, 'f'), regular_const=1e-2)\n",
    "globals()[\"time_\"+alg] = time.time() - start\n",
    "print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = z_test, direct = False,\n",
    "                                                                                                Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "plt.boxplot(globals()[\"loss_\"+alg], showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01bf6e90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*********************************************************\n",
      "Trial 1\n",
      "Time cost 3.4068288803100586\n",
      "Method Kernelized SVM Margin Learning\n",
      "Training samples 500\n"
     ]
    }
   ],
   "source": [
    "for trial in range(total_trial):\n",
    "    # Generate Fractional Knapsack Samples\n",
    "    benchmark = 1\n",
    "    dim_features = 5\n",
    "    dim_decision = 10\n",
    "    price = np.random.randint(low=1, high=1000, size=dim_decision)\n",
    "    lower = np.amax(price)\n",
    "    upper = (np.random.rand()-1)*lower + np.sum(price)\n",
    "    Budget = [(upper-lower)*np.random.rand() + lower]\n",
    "    Coeff_Mat = np.random.binomial(n=1, p=0.5, size = (dim_decision, dim_features))\n",
    "    Theta_true = -np.concatenate((Coeff_Mat, np.zeros((dim_decision+1, dim_features))), axis=0)\n",
    "    print(\"*********************************************************\")\n",
    "    print(\"Trial\", trial + 1)\n",
    "    \n",
    "    N_train = 500\n",
    "    # N_valid = 200\n",
    "    N_test = 1000\n",
    "    degree = 1\n",
    "    additive_noise = 0.0\n",
    "    scale_noise_uni = 0.0\n",
    "    scale_noise_div = 0.0\n",
    "    attack_threshold = None\n",
    "    attack_power = 0.0\n",
    "    z_train, c_train, A_train, b_train = dg.GenerateFractionalKnapsack(N_samples=N_train, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "                                        degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)\n",
    "    # z_valid, c_valid, A_valid, b_valid = dg.GenerateFractionalKnapsack(N_samples=N_valid, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "    #                                     degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)\n",
    "    z_test, c_test, A_test, b_test = dg.GenerateFractionalKnapsack(N_samples=N_test, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "                                        degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)\n",
    "    # Compute Optimal Solutions\n",
    "    start = time.time()\n",
    "    basic_train, nonb_train, solution_train = lpm.ComputeBasis(c=c_train, A=A_train, b=b_train)\n",
    "    #basic_valid, nonb_valid, solution_valid = lpm.ComputeBasis(c=c_valid, A=A_valid, b=b_valid)\n",
    "    basic_test, nonb_test, solution_test = lpm.ComputeBasis(c=c_test, A=A_test, b=b_test)\n",
    "    print(\"Time cost\", time.time() - start)\n",
    "    \n",
    "    \n",
    "    # Kernelized Margin Learning\n",
    "    # Do not need true c\n",
    "    # Do not need solution x but basis\n",
    "    alg = 'ExpRbf'\n",
    "    ker_z_train = lm.ExpKernel(z = z_train, benchmark_z = z_train, gamma=1e-1)\n",
    "    ker_z_test = lm.ExpKernel(z = z_test, benchmark_z = z_train, gamma=1e-1)\n",
    "    print(\"Method Kernelized SVM Margin Learning\")\n",
    "    print(\"Training samples\", N_train)\n",
    "    start = time.time()\n",
    "    globals()[\"Theta_\"+alg] = lm.KernelizedMarginLearning(A = A_train, b = b_train, z = ker_z_train, basic = basic_train, nonb = nonb_train,\n",
    "                                                          regular_const=0)\n",
    "    globals()[\"time_\"+alg] = time.time() - start\n",
    "    print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "    globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = ker_z_test, direct = False,\n",
    "                                                                                                    Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "    print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "    mark = 0\n",
    "    for j in range(len(globals()[focus + \"_set\"])):\n",
    "        if globals()[focus] == globals()[focus + \"_set\"][j]:\n",
    "            mark = j\n",
    "    globals()[\"Loss_\" + alg][trial][mark] = np.average(globals()[\"loss_\" + alg])\n",
    "    globals()[\"Error_\" + alg][trial][mark] = np.average(globals()[\"error_\" + alg])\n",
    "    globals()[\"Norm_Err_\" + alg][trial][mark] = np.average(globals()[\"norm_err_\" + alg])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "d1caaea7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# degree 4\n",
    "i = 0\n",
    "data_name = [\"Loss\", \"Error\", \"Norm_Err\"]\n",
    "for data in data_name:\n",
    "    tmp = np.zeros((total_trial, len(methods)))\n",
    "    for j in range(len(methods)):\n",
    "        tmp[:, j] = globals()[data+\"_\"+methods[j]].T[i]\n",
    "    np.savetxt(os.path.join('Degree', f\"{data}_degree_{degree_set[i]}_Ker\"), tmp)\n",
    "    sns.boxplot(data = tmp, showfliers = False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "b31566f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAPlUlEQVR4nO3db2hd933H8ffHTkLSpCXtLJJgpXWY3HWmtF0QphDInI0WpxSy7VG80bKuxQySeX1QWBhjga2wPiiDCrIG05kQWBMGayCUrOmTDT9oOywnWWunS32Xps2t01qtl39z0tTxdw90zVRXsq7se3V8f3q/QEj3/I7O/UhyPjn66dzzS1UhSWrXpq4DSJLGy6KXpMZZ9JLUOItekhpn0UtS4y7rOsBytmzZUtu2bes6hiRNjMOHD/+0qqaWG7ski37btm3Mz893HUOSJkaSH6w05tSNJDXOopekxln0ktQ4i16SGmfRS1LjLHpJapxFL0mNuySvo+/a3NwcvV5v5Mft9/sATE9Pj/zYADMzM+zbt28sx5Y0uSz6dfTaa691HUHSBmTRL2NcZ8Vnjzs3NzeW40vScpyjl6TGWfSS1DiLXpIaZ9FLUuMseklqnEUvSY2z6CWpcRa9JDXOopekxln0ktQ4i16SGmfRS1LjLHpJapxFL0mNW7XokxxIciLJkRXG/yjJtwdv30jy/iVju5M8k6SX5J5RBpckDWeYM/oHgN3nGf8+8NtV9T7gb4H9AEk2A/cBtwM7gD1JdlxUWknSmq1a9FV1EDh5nvFvVNX/DB5+Czi7Tt5OoFdVz1bVG8DDwB0XmVeStEajnqP/JPCvg4+3As8vGesPti0ryd4k80nmFxYWRhxLkjaukRV9kttYLPq/OLtpmd1qpc+vqv1VNVtVs1NTU6OKJUkb3kjWjE3yPuBLwO1V9bPB5j5w45LdpoHjo3g+SdLwLvqMPsk7ga8AH6uq7y0ZOgRsT3JTkiuAO4FHL/b5JElrs+oZfZKHgF3AliR94F7gcoCquh/4a+DXgH9IAnB6MAVzOsndwOPAZuBAVR0dy1chSVrRqkVfVXtWGf8U8KkVxh4DHruwaJKkUfCVsZLUOItekhpn0UtS4yx6SWqcRS9JjbPoJalxFr0kNc6il6TGWfSS1DiLXpIaZ9FLUuMseklqnEUvSY2z6CWpcRa9JDXOopekxln0ktQ4i16SGmfRS1LjLHpJatyqi4Nfyubm5uj1el3HGNqxY8cA2LdvX8dJ1mZmZmbiMkv6fxNd9L1ejye/8zRn3vKOrqMMJW8UAIf/+8cdJxneplMnu44g6SJNdNEDnHnLO3h9x0e7jtGsK5/+atcRJF2kVefokxxIciLJkRXG35Pkm0l+nuQz54w9l+Q7SZ5KMj+q0JKk4Q3zx9gHgN3nGT8J7AM+v8L4bVX1gaqaXWM2SdIIrFr0VXWQxTJfafxEVR0CfjHKYJKk0Rj35ZUFfD3J4SR7z7djkr1J5pPMLywsjDmWJG0c4y76W6rqZuB24K4kt660Y1Xtr6rZqpqdmpoacyxJ2jjGWvRVdXzw/gTwCLBznM8nSfpVYyv6JFcneevZj4EPA8teuSNJGp9Vr6NP8hCwC9iSpA/cC1wOUFX3J7kemAfeBpxJ8mlgB7AFeCTJ2ef5clV9bQxfgyTpPFYt+qras8r4j4HpZYZeBt5/gbkkSSPiTc0kqXEWvSQ1bqLvddPv99l06iXvxzJGm079jH7/dNcxJF0Ez+glqXETfUY/PT3NT35+mXevHKMrn/4q09PXdx1D0kXwjF6SGmfRS1LjLHpJapxFL0mNs+glqXEWvSQ1zqKXpMZZ9JLUOItekhpn0UtS4yx6SWqcRS9JjbPoJalxFr0kNW6ib1MMsOnUyYlZeCSvvwxAXfm2jpMMb9Opk4C3KZYm2UQX/czMTNcR1uTYsVcA2P7rk1Sc10/c91nSL5voot+3b1/XEdbkbN65ubmOk0jaSJyjl6TGrVr0SQ4kOZHkyArj70nyzSQ/T/KZc8Z2J3kmSS/JPaMKLUka3jBn9A8Au88zfhLYB3x+6cYkm4H7gNuBHcCeJDsuLKYk6UKtWvRVdZDFMl9p/ERVHQJ+cc7QTqBXVc9W1RvAw8AdFxNWkrR245yj3wo8v+Rxf7BtWUn2JplPMr+wsDDGWJK0sYyz6LPMtlpp56raX1WzVTU7NTU1xliStLGMs+j7wI1LHk8Dx8f4fJKkZYyz6A8B25PclOQK4E7g0TE+nyRpGau+YCrJQ8AuYEuSPnAvcDlAVd2f5HpgHngbcCbJp4EdVfVykruBx4HNwIGqOjqWr0KStKJVi76q9qwy/mMWp2WWG3sMeOzCokmSRsFXxkpS4yb6XjeS2jI3N0ev1xvLsfv9PgDT08tOQFyUmZmZS/reWxa9pA3htdde6zpCZyx6SZeMcZ4Vb+S7xzpHL0mNs+glqXEWvSQ1zqKXpMZZ9JLUOItekhpn0UtS4yx6SWqcRS9JjbPoJalxFr0kNc6il6TGWfSS1DiLXpIa522KlzGuxQ+OHTsGjO9WrJf64geSumHRr6Orrrqq6wiSNiCLfhmeFUtqiUWv5oxr6m0jrzmqyWbRS0PayGuOarKtWvRJDgAfBU5U1XuXGQ/wBeAjwCngj6vqicHYc8ArwJvA6aqaHV10aXnjOjPeyGuOarINc3nlA8Du84zfDmwfvO0FvnjO+G1V9QFLXpK6sWrRV9VB4OR5drkDeLAWfQu4NskNowooSbo4o3jB1Fbg+SWP+4NtAAV8PcnhJHvPd5Ake5PMJ5lfWFgYQSxJEoym6LPMthq8v6WqbmZxeueuJLeudJCq2l9Vs1U1OzU1NYJYkiQYTdH3gRuXPJ4GjgNU1dn3J4BHgJ0jeD5J0hqMougfBT6eRR8EXqqqF5JcneStAEmuBj4MHBnB80mS1mCYyysfAnYBW5L0gXuBywGq6n7gMRYvreyxeHnlJwafeh3wyOLVl1wGfLmqvjbi/JKkVaxa9FW1Z5XxAu5aZvuzwPsvPJokaRS8TbEkNc6il6TGWfSS1DiLXpIaZ9FLUuMseklqnEUvSY2z6CWpcRa9JDXOpQQlrdm41uUdp2PHjgHjW4FsHEa1lrBFL2nNer0eTx59Eq7tOskanFl89+SPnuw2x7BeHN2hLHpJF+ZaOLPrTNcpmrXp30c3s+4cvSQ1zqKXpMZZ9JLUOItekhpn0UtS4yx6SWqcRS9JjbPoJalxFr0kNc6il6TGWfSS1LhViz7JgSQnkhxZYTxJ5pL0knw7yc1LxnYneWYwds8og0uShjPMGf0DwO7zjN8ObB+87QW+CJBkM3DfYHwHsCfJjosJK0lau1WLvqoOAifPs8sdwIO16FvAtUluAHYCvap6tqreAB4e7CtJWkejmKPfCjy/5HF/sG2l7ctKsjfJfJL5hYWFEcSSJMFoij7LbKvzbF9WVe2vqtmqmp2amhpBLEkSjGbhkT5w45LH08Bx4IoVtkuS1tEozugfBT4+uPrmg8BLVfUCcAjYnuSmJFcAdw72lSSto1XP6JM8BOwCtiTpA/cClwNU1f3AY8BHgB5wCvjEYOx0kruBx4HNwIGqOjqGr0GSdB6rFn1V7VllvIC7Vhh7jMX/EUhqSL/fh5dGu66pzvEi9Ks/kkO5OLg6MTc3R6/X6zrGmhw7dgyAffv2dZxkbWZmZiYus0bLolcner0e3zvyBO+85s2uowztil8snr2+/tyhjpMM74evbh7Lcaenp1nIAmd2nRnL8bX429L01umRHMuiV2feec2b/NXsq13HaNpn56/pOoIuAU6wSVLjLHpJapxFL0mNs+glqXEWvSQ1zqtuJF2YFyfsBVNnL/CalAuRXuQ89/tdG4te0prNzMx0HWHNzr7gbfvW7R0nGdLW0X2fLXpJazaJr7Q9m3lubq7jJOtvgn7vkiRdCItekhpn0UtS4yx6SWqcRS9JjbPoJalxFr0kNc6il6TGWfSS1DiLXpIa5y0Q1Il+v8//vrLZpe7G7AevbObqfr/rGOqYZ/SS1LihzuiT7Aa+AGwGvlRVnztn/O3AAeDXgdeBP6mqI4Ox54BXgDeB01U1O7L0mljT09O8fvoFFwcfs8/OX8OV09Ndxxja3NwcvV5vLMc+e/fKcdyQbWZm5pK+0duqRZ9kM3Af8CGgDxxK8mhVPb1kt78Enqqq30/ynsH+v7tk/Laq+ukIc0vSmlx11VVdR+jMMGf0O4FeVT0LkORh4A5gadHvAP4OoKr+K8m2JNdV1U9GHVhSuy7ls+JJNswc/Vbg+SWP+/zquif/CfwBQJKdwLuAs78vFvD1JIeT7F3pSZLsTTKfZH5hYWHY/JKkVQxT9FlmW53z+HPA25M8BfwZ8CRwejB2S1XdDNwO3JXk1uWepKr2V9VsVc1OTU0NFV6StLphpm76wI1LHk8Dx5fuUFUvA58ASBLg+4M3qur44P2JJI+wOBV08KKTS5KGMkzRHwK2J7kJ+BFwJ/CHS3dIci1wqqreAD4FHKyql5NcDWyqqlcGH38Y+JtRfgGaXD98dbKuo//JqcVfgK97y5mOkwzvh69u5t1dh1DnVi36qjqd5G7gcRYvrzxQVUeT/Olg/H7gN4EHk7zJ4h9pPzn49OuARxZP8rkM+HJVfW30X4YmzSQuLv3G4PK8K7dNyOLSwLuZzO+1RitV5063d292drbm5+e7jiH9ko28uLQufUkOr/Q6JV8ZK0mNs+glqXEWvSQ1zqKXpMZZ9JLUOItekhpn0UtS4yx6SWqcRS9JjbPoJalxFr0kNc6il6TGDbU4uDRJxrXA9EZeXFqTzaKXhrSRF5fWZLPo1RzPjKVf5hy9JDXOopekxln0ktQ4i16SGmfRS1LjLHpJapxFL0mNs+glqXGpqq4z/IokC8APus4xJluAn3YdQhfMn99ka/nn966qmlpu4JIs+pYlma+q2a5z6ML485tsG/Xn59SNJDXOopekxln0629/1wF0Ufz5TbYN+fNzjl6SGucZvSQ1zqKXpMZZ9Osoye4kzyTpJbmn6zwaXpIDSU4kOdJ1Fq1NkhuT/FuS7yY5muTPu8603pyjXydJNgPfAz4E9IFDwJ6qerrTYBpKkluBV4EHq+q9XefR8JLcANxQVU8keStwGPi9jfTfnmf062cn0KuqZ6vqDeBh4I6OM2lIVXUQONl1Dq1dVb1QVU8MPn4F+C6wtdtU68uiXz9bgeeXPO6zwf6xSV1Lsg34LeA/Oo6yriz69ZNltjlvJq2TJNcA/wJ8uqpe7jrPerLo108fuHHJ42ngeEdZpA0lyeUslvw/VdVXus6z3iz69XMI2J7kpiRXAHcCj3acSWpekgD/CHy3qv6+6zxdsOjXSVWdBu4GHmfxj0H/XFVHu02lYSV5CPgm8BtJ+kk+2XUmDe0W4GPA7yR5avD2ka5DrScvr5SkxnlGL0mNs+glqXEWvSQ1zqKXpMZZ9JLUOItekhpn0UtS4/4PRGQHWjkMpg4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# degree 6\n",
    "i = 1\n",
    "data_name = [\"Loss\", \"Error\", \"Norm_Err\"]\n",
    "for data in data_name:\n",
    "    tmp = np.zeros((total_trial, len(methods)))\n",
    "    for j in range(len(methods)):\n",
    "        tmp[:, j] = globals()[data+\"_\"+methods[j]].T[i]\n",
    "    np.savetxt(os.path.join('Degree', f\"{data}_degree_{degree_set[i]}_Ker\"), tmp)\n",
    "    sns.boxplot(data = tmp, showfliers = False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "f0776ae6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# degree 1\n",
    "i = 2\n",
    "data_name = [\"Loss\", \"Error\", \"Norm_Err\"]\n",
    "for data in data_name:\n",
    "    tmp = np.zeros((total_trial, len(methods)))\n",
    "    for j in range(len(methods)):\n",
    "        tmp[:, j] = globals()[data+\"_\"+methods[j]].T[i]\n",
    "    np.savetxt(os.path.join('Degree', f\"{data}_degree_{degree_set[i]}_Ker\"), tmp)\n",
    "    sns.boxplot(data = tmp, showfliers = False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "96195440",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# degree 2\n",
    "i = 3\n",
    "data_name = [\"Loss\", \"Error\", \"Norm_Err\"]\n",
    "for data in data_name:\n",
    "    tmp = np.zeros((total_trial, len(methods)))\n",
    "    for j in range(len(methods)):\n",
    "        tmp[:, j] = globals()[data+\"_\"+methods[j]].T[i]\n",
    "    np.savetxt(os.path.join('Degree', f\"{data}_degree_{degree_set[i]}_Ker\"), tmp)\n",
    "    sns.boxplot(data = tmp, showfliers = False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3ae50569",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 0\n",
    "data_name = [\"Loss\", \"Error\", \"Norm_Err\"]\n",
    "for data in data_name:\n",
    "    tmp = np.zeros((total_trial, len(methods)))\n",
    "    for j in range(len(methods)):\n",
    "        tmp[:, j] = globals()[data+\"_\"+methods[j]].T[i]\n",
    "    np.savetxt(os.path.join('Attack_Power', f\"{data}_power_{attack_power_set[i]}\"), tmp)\n",
    "    sns.boxplot(data = tmp, showfliers = False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "dd79b340",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 1\n",
    "data_name = [\"Loss\", \"Error\", \"Norm_Err\"]\n",
    "for data in data_name:\n",
    "    tmp = np.zeros((total_trial, len(methods)))\n",
    "    for j in range(len(methods)):\n",
    "        tmp[:, j] = globals()[data+\"_\"+methods[j]].T[i]\n",
    "    np.savetxt(os.path.join('Attack_Power', f\"{data}_power_{attack_power_set[i]}\"), tmp)\n",
    "    sns.boxplot(data = tmp, showfliers = False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3a598795",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 2\n",
    "data_name = [\"Loss\", \"Error\", \"Norm_Err\"]\n",
    "for data in data_name:\n",
    "    tmp = np.zeros((total_trial, len(methods)))\n",
    "    for j in range(len(methods)):\n",
    "        tmp[:, j] = globals()[data+\"_\"+methods[j]].T[i]\n",
    "    np.savetxt(os.path.join('Attack_Power', f\"{data}_power_{attack_power_set[i]}\"), tmp)\n",
    "    sns.boxplot(data = tmp, showfliers = False)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2761bb1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.12922369 0.11743162 0.16924198 0.16297437 0.13077465 0.15823413\n",
      " 0.14790405 0.17031298 0.15833414 0.18191709 0.15625121 0.19096635\n",
      " 0.15535143 0.15031566 0.18060388 0.15342378 0.12405103 0.21309579\n",
      " 0.11811923 0.15956173 0.14396253 0.1942669  0.13780931 0.15165267\n",
      " 0.12863871 0.15474835 0.12454046 0.13749102 0.17122848 0.17815233]\n"
     ]
    }
   ],
   "source": [
    "print(globals()[data+\"_\"+methods[j]].T[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "29a2d35a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD4CAYAAADlwTGnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAXk0lEQVR4nO3df4wd1X338ffHCw7mlwxlAcvXrml2G4Sq1omuTCSkijQPkU2jmPyRylQlJEV1kGJtUBs1bvToUR61f1gRSZqVEJaTWCJ60jhUCcoqtUIQBVWRINm1ccA/Qn1jGbjYsZdQwNQOZr3f54+ZbW+v17szu/d69u75vKTVvTNzzpkzsN7PnTMz9ygiMDOz9CypugNmZlYNB4CZWaIcAGZmiXIAmJklygFgZpaoS6ruQBnXXXddrFmzpupumJn1lD179rwWEf3t63sqANasWcPY2FjV3TAz6ymSXppuvYeAzMwS5QAwM0uUA8DMLFEOADOzRDkAzMwS5QAwM0uUA8DMLFE99RzAfA0PD9NoNAqVbTabANRqtULlBwYGGBoamnPfzMwutqQCoIwzZ85U3QUzs65KKgDKfEKfKjs8PNyt7piZVcrXAMzMEuUAMDNLlAPAzCxRDgAzs0Q5AMzMEuUAMDNLlAPAzCxRDgAzs0Q5AMzMElUoACStl/SipIakrdNsv1nSM5LekfT5lvXvk7Sv5ectSQ/k274k6dWWbXd27KjMzGxWs34VhKQ+4CHgDqAJjEoaiYiDLcVeB4aAu1rrRsSLwNqWdl4FHmsp8rWIeHAe/TczszkqcgawDmhExJGIOAvsAja2FoiIkxExCrw7QzsfBn4VEdPOTm9mZhdXkQBYCbzSstzM15W1Cfhu27otkp6XtFPSNXNo08zM5qhIAGiadVFmJ5KWAh8D/rll9cPAe8mGiI4DX7lA3c2SxiSNjY+Pl9mtmZnNoEgANIFVLcs14FjJ/WwA9kbEiakVEXEiIs5FxCTwDbKhpvNExI6IqEdEvb+/v+RuzczsQooEwCgwKOmm/JP8JmCk5H7upm34R9KKlsWPA/tLtmlmZvMw611AETEhaQvwONAH7IyIA5Luz7dvl3QjMAZcDUzmt3reEhFvSbqc7A6iz7Q1/WVJa8mGk45Os93MzLqo0IxgEbEb2N22bnvL+1+TDQ1NV/c08DvTrL+nVE/NzKyj/CSwmVmiHABmZolyAJiZJcoBYGaWKAeAmVmiHABmZolyAJiZJcoBYGaWKAeAmVmiCj0JvJANDw/TaDQ63u7hw4cBGBoa6njbAwMDXWnXzKyMng+ARqPBcy8cZPLyazvars5m33i951e/7mi7S06/3tH2zMzmqucDAGDy8mv57S0frbobhVx28EdVd8HMDPA1ADOzZDkAzMwS5QAwM0uUA8DMLFEOADOzRDkAzMwSVSgAJK2X9KKkhqSt02y/WdIzkt6R9Pm2bUclvSBpn6SxlvXXSnpC0uH89Zr5H46ZmRU1awBI6gMeAjYAtwB3S7qlrdjrwBDw4AWa+VBErI2Iesu6rcCTETEIPJkvm5nZRVLkQbB1QCMijgBI2gVsBA5OFYiIk8BJSX9aYt8bgdvz948ATwNfKFEfgGazyZLTb/bMA1ZLTv+GZnOi6m6YmRUaAloJvNKy3MzXFRXATyTtkbS5Zf0NEXEcIH+9frrKkjZLGpM0Nj4+XmK3ZmY2kyJnAJpmXZTYx20RcUzS9cATkn4ZEf9WtHJE7AB2ANTr9fP2W6vVOPHOJT31VRC12o1Vd8PMrNAZQBNY1bJcA44V3UFEHMtfTwKPkQ0pAZyQtAIgfz1ZtE0zM5u/IgEwCgxKuknSUmATMFKkcUlXSLpq6j3wEWB/vnkEuDd/fy/wwzIdNzOz+Zl1CCgiJiRtAR4H+oCdEXFA0v359u2SbgTGgKuBSUkPkN0xdB3wmKSpff1TRPw4b3ob8Kik+4CXgU909MjMzGxGhb4OOiJ2A7vb1m1vef9rsqGhdm8Bf3SBNn8DfLhwT83MrKP8JLCZWaIcAGZmiXIAmJklalFMCbnk9OsdfxJYv30LgLjs6o62m80J7OcAzKx6PR8AAwMDXWn38OFTAAy+t9N/rG/sWp/NzMro+QAYGhrqarvDw8Ndad/MrGq+BmBmligHgJlZohwAZmaJcgCYmSXKAWBmligHgJlZohwAZmaJcgCYmSXKAWBmligHgJlZohwAZmaJKhQAktZLelFSQ9LWabbfLOkZSe9I+nzL+lWSnpJ0SNIBSZ9r2fYlSa9K2pf/3NmZQzIzsyJm/TI4SX3AQ8AdQBMYlTQSEQdbir0ODAF3tVWfAP4mIvbmk8PvkfRES92vRcSD8z0IMzMrr8gZwDqgERFHIuIssAvY2FogIk5GxCjwbtv64xGxN39/CjgErOxIz83MbF6KBMBK4JWW5SZz+CMuaQ3wfuBnLau3SHpe0k5J11yg3mZJY5LGxsfHy+7WzMwuoEgAaJp1UWYnkq4Evg88EBFv5asfBt4LrAWOA1+Zrm5E7IiIekTU+/v7y+zWzMxmUCQAmsCqluUacKzoDiRdSvbH/zsR8YOp9RFxIiLORcQk8A2yoSYzM7tIigTAKDAo6SZJS4FNwEiRxiUJ+BZwKCK+2rZtRcvix4H9xbpsZmadMOtdQBExIWkL8DjQB+yMiAOS7s+3b5d0IzAGXA1MSnoAuAX4Q+Ae4AVJ+/ImvxgRu4EvS1pLNpx0FPhMB4/LzMxmUWhO4PwP9u62ddtb3v+abGio3U+Z/hoCEXFP8W6amVmn+UlgM7NEOQDMzBLlADAzS5QDwMwsUQ4AM7NEOQDMzBLlADAzS5QDwMwsUYUeBFsshoeHaTQahcoePnwYgKGhoULlBwYGCpc1M1sIkgqAMpYtW1Z1F8zMuiqpAPAndDOz/+ZrAGZmiXIAmJklygFgZpYoB4CZWaIcAGZmiXIAmJklqlAASFov6UVJDUlbp9l+s6RnJL0j6fNF6kq6VtITkg7nr9fM/3DMzKyoWQNAUh/wELCBbJ7fuyXd0lbsdWAIeLBE3a3AkxExCDyZL5uZ2UVS5AxgHdCIiCMRcRbYBWxsLRARJyNiFHi3RN2NwCP5+0eAu+Z2CGZmNhdFAmAl8ErLcjNfV8RMdW+IiOMA+ev10zUgabOkMUlj4+PjBXdrZmazKRIAmmZdFGx/PnWzwhE7IqIeEfX+/v4yVc3MbAZFAqAJrGpZrgHHCrY/U90TklYA5K8nC7ZpZmYdUCQARoFBSTdJWgpsAkYKtj9T3RHg3vz9vcAPi3fbzMzma9ZvA42ICUlbgMeBPmBnRByQdH++fbukG4Ex4GpgUtIDwC0R8dZ0dfOmtwGPSroPeBn4RIePzczMZqCIUkPylarX6zE2NlZ1N8zMeoqkPRFRb1/vJ4HNzBLlADAzS5QDwMwsUQ4AM7NEOQDMzBLlADAzS5QDwMwsUQ4AM7NEOQDMzBLlADAzS5QDwMwsUQ4AM7NEOQDMzBLlADAzS5QDwMwsUQ4AM7NEOQDMzBI165SQAJLWA18nm9bxmxGxrW278u13AqeBT0XEXknvA77XUvT3gP8TEf8o6UvAXwHj+bYvRsTu+RyMmVkVhoeHaTQahco2m00AarVaofIDAwMMDQ3NuW8zmTUAJPUBDwF3AE1gVNJIRBxsKbYBGMx/bgUeBm6NiBeBtS3tvAo81lLvaxHxYAeOw8ysJ5w5c6bqLvyXImcA64BGRBwBkLQL2Ai0BsBG4NuRTTD8rKTlklZExPGWMh8GfhURL3Wo72ZmC0KZT+hTZYeHh7vVncKKXANYCbzSstzM15Utswn4btu6LZKel7RT0jUF+mJmZh1S5AxA06yLMmUkLQU+Bvxdy/aHgb/Py/098BXgL8/bubQZ2AywevXqAt1NU5kxSFhY45BFdHOMFao/PrMqFDkDaAKrWpZrwLGSZTYAeyPixNSKiDgREeciYhL4BtlQ03kiYkdE1COi3t/fX6C7VsSZM2cW1FhkJy3mYzPrpCJnAKPAoKSbyC7ibgL+vK3MCNlwzi6yi8Bvto3/303b8E/bNYKPA/vn0H/Llf30upDGIYvo1TFWs4Vs1gCIiAlJW4DHyW4D3RkRByTdn2/fDuwmuwW0QXYb6Ken6ku6nOwOos+0Nf1lSWvJhoCOTrPdzMy6qNBzAPn9+bvb1m1veR/AZy9Q9zTwO9Osv6dUT83MrKP8JLCZWaIcAGZmiXIAmJklygFgZpYoB4CZWaIcAGZmiXIAmJklygFgZpaoQg+CmZmlpuwXLBZ1+PBhoPzXtxRR9ksNHQBmZtNoNBrs/8UvuGppZ/9MTkycA+ClQwc62u6psxOl6zgAzMwu4Kqll7Duht6YquTnJ/6jdB1fAzAzS5QDwMwsUQ4AM7NEOQDMzBLlADAzS5QDwMwsUb4NdAHr1oMosDAeRunFB22g/MM2ZgtVoQCQtB74OtmcwN+MiG1t25Vvv5NsTuBPRcTefNtR4BRwDpiIiHq+/lrge8AasjmB/ywiyt/Iuog1Gg3+ff9eVl95ruNtL303O/n77dHRjrb78tt9hcs2Gg2eO/AcLO9oF2Aye3nu1ec63DDwRuebNKvKrAEgqQ94iGxi9yYwKmkkIg62FNsADOY/twIP569TPhQRr7U1vRV4MiK2SdqaL39hzkeySK2+8hz/u/521d0o7B/GrixXYTlM3j7Zlb50w5KnPWpqi0eR3+Z1QCMijkTEWWAXsLGtzEbg25F5FlguacUs7W4EHsnfPwLcVbzbZmY2X0UCYCXwSstyM19XtEwAP5G0R9LmljI3RMRxgPz1+ul2LmmzpDFJY+Pj4wW6a2ZmRRQJAE2zLkqUuS0iPkA2TPRZSX9con9ExI6IqEdEvb+/v0xVMzObQZEAaAKrWpZrwLGiZSJi6vUk8BjZkBLAialhovz1ZNnOm5nZ3BUJgFFgUNJNkpYCm4CRtjIjwCeV+SDwZkQcl3SFpKsAJF0BfATY31Ln3vz9vcAP53ksZmZWwqx3AUXEhKQtwONkt4HujIgDku7Pt28HdpPdAtoguw3003n1G4DHsrtEuQT4p4j4cb5tG/CopPuAl4FPdOyozMzmqdlscursxJy+ZrkKp85O0Gw2S9Up9BxAROwm+yPfum57y/sAPjtNvSPAH12gzd8AHy7T2dQ0m03+81Rf+VsrK/TSqT6uKPlLaGbV8JPAVplmswlv9ti99W9AMxxwKajVapw79WZPTQhTq9VK1XEALGC1Wo3fThzvuQfBLiv5S2hm1XAAWGVqtRrjGu+5J4FrKx1wtjj00Lm3mZl1ks8AzMwuoBt3AZ2eyL7c8fJLin9xYhGnzk6UruMAWOBefrs7dwGdOJ2d/N1weWeHX15+u4/fL1PhjS5cBJ66ZNKNm6fe4PwvQrFFaWBgoCvtTn1d+e8ODna87bJ9dgAsYN36BQQ4m/8SXrams7+Ev0/xfnf7H9jgys7/A2Nld/+/2MLRrTkfptodHh7uSvtlOAAWsG5OOrIQfglT+AdmtpD5IrCZWaIcAGZmiXIAmJklygFgZpYoXwQ2M5un4eFhGo1GobJTd6kVvQliYGCgazdMOADMzC6iZcuWVd2F/+IAMDObp27est1NvgZgZpYoB4CZWaIKBYCk9ZJelNSQtHWa7ZI0nG9/XtIH8vWrJD0l6ZCkA5I+11LnS5JelbQv/7mzc4dlZmazmfUagKQ+4CHgDqAJjEoaiYiDLcU2AIP5z63Aw/nrBPA3EbE3nxx+j6QnWup+LSIe7NzhmJlZUUXOANYBjYg4EhFngV3AxrYyG4FvR+ZZYLmkFRFxPCL2AkTEKeAQ/i5FM7MFochdQCuBV1qWm2Sf7mcrsxI4PrVC0hrg/cDPWsptkfRJYIzsTOG8L96WtBnYDLB69eoC3U1TmfuQYWHdi1xEN++zhuqPz6wKRc4ANM26KFNG0pXA94EHIuKtfPXDwHuBtWRB8ZXpdh4ROyKiHhH1/v7+At21IpYtW7ag7kfupMV8bGadVOQMoAmsalmuAceKlpF0Kdkf/+9ExA+mCkTEian3kr4B/KhUz+1/WOyfXhf78ZlVocgZwCgwKOkmSUuBTcBIW5kR4JP53UAfBN6MiOOSBHwLOBQRX22tIGlFy+LHgf1zPgozMytt1jOAiJiQtAV4HOgDdkbEAUn359u3A7uBO4EGcBr4dF79NuAe4AVJ+/J1X4yI3cCXJa0lGyo6CnymQ8dkZmYFKKJ9OH/hqtfrMTY2VnU3zMx6iqQ9EVFvX+8ngc3MEuUAMDNLlAPAzCxRDgAzs0Q5AMzMEuUAMDNLlAPAzCxRDgAzs0Q5AMzMEuUAMDNLVJFvAzUzm5cy8zk0m00AarVaofKey2HuHABmtqCcOXOm6i4kwwFgZl1X5hP6VNnh4eFudcdyDgAzm5Oy05AWNZcpPYvycNH/5AAwszlpNBoceOEQyy+/vqPtTp7NZph99Ve/6Wi7b5w+2dH2FgMHgNkC0KsXSZdffj0funlTV9rutKd+uavqLiw4DgCzHrNQLpI2m03ePH2qZ/6wvnH6JNFcGP/tFopCASBpPfB1sikhvxkR29q2K99+J9mUkJ+KiL0z1ZV0LfA9YA3ZlJB/FhH/Mf9DMlsYujVGXlaj0Sh1BlDmjGHi3NmOD62cm3wXgL4ll3a03YlzZzva3mIwawBI6gMeAu4AmsCopJGIONhSbAMwmP/cCjwM3DpL3a3AkxGxTdLWfPkLnTs0s2o9/fTTvPbaa11rf9++fV1pt9lsFgqA22+/vdSwVdEzlzNnsgBYelmxAYply5aVGg6z/1bkv/A6oBERRwAk7QI2Aq0BsBH4dmQTDD8rabmkFWSf7i9UdyNwe17/EeBpHAC2iCxfvrzwH7133nmHycnJQmWnyi1ZUuxB/iVLlvCe97ynUFnI+l1EmbOKXr3GsdgVCYCVwCsty02yT/mzlVk5S90bIuI4QEQclzTtrQSSNgObAVavXl2gu2YLw86dOwuXXex/IKvev02vSABomnVRsEyRujOKiB3ADoB6vV6qrlmv8B9Iq0KRc8gmsKpluQYcK1hmpron8mEi8lffpGtmdhEVCYBRYFDSTZKWApuAkbYyI8Anlfkg8GY+vDNT3RHg3vz9vcAP53ksZmZWwqxDQBExIWkL8DjZrZw7I+KApPvz7duB3WS3gDbIbgP99Ex186a3AY9Kug94GfhER4/MzMxmpOzGnd5Qr9djbGys6m6YmfUUSXsiot6+3hPCmJklygFgZpYoB4CZWaIcAGZmieqpi8CSxoGXLuIurwO692Uu1VvMx7eYjw18fL3uYh/f70ZEf/vKngqAi03S2HRXzheLxXx8i/nYwMfX6xbK8XkIyMwsUQ4AM7NEOQBmtqPqDnTZYj6+xXxs4OPrdQvi+HwNwMwsUT4DMDNLlAPAzCxRDoBpSFov6UVJjXy+4kVF0k5JJyXtr7ovnSZplaSnJB2SdEDS56ruUydJukzSzyX9Ij++/1t1nzpNUp+k5yT9qOq+dJqko5JekLRPUuXfbOlrAG3yiez/nZaJ7IG784nsFwVJfwy8TTaP8x9U3Z9OyicXWhEReyVdBewB7los//8kCbgiIt6WdCnwU+BzEfFsxV3rGEl/DdSBqyPio1X3p5MkHQXqEbEgHnLzGcD51pFPZB8RZ4GpiewXjYj4N+D1qvvRDRFxPCL25u9PAYfI5qZeFCLzdr54af6zaD7FSaoBfwp8s+q+pMABcL4LTXBvPUbSGuD9wM8q7kpH5UMk+8imUX0iIhbT8f0j8LfAZMX96JYAfiJpj6TNVXfGAXC+eU9kb9WTdCXwfeCBiHir6v50UkSci4i1ZHNsr5O0KIbxJH0UOBkRe6ruSxfdFhEfADYAn82HYyvjADjfTBPZWw/Ix8a/D3wnIn5QdX+6JSLeAJ4G1lfbk465DfhYPk6+C/gTSf+v2i51VkQcy19PAo+RDTlXxgFwvpkmsrcFLr9I+i3gUER8ter+dJqkfknL8/fLgP8F/LLSTnVIRPxdRNQiYg3Zv7t/jYi/qLhbHSPpivzGBCRdAXwEqPROPAdAm4iYAKYmsj8EPNoykf2iIOm7wDPA+yQ1Jd1XdZ866DbgHrJPj/vynzur7lQHrQCekvQ82YeVJyJi0d0uuUjdAPxU0i+AnwP/EhE/rrJDvg3UzCxRPgMwM0uUA8DMLFEOADOzRDkAzMwS5QAwM0uUA8DMLFEOADOzRP1/NSXScLS7sFEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 1\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Attack_Power', f\"Loss_power{attack_power_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Attack_Power', f\"Error_power{attack_power_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "d23944e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 2\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Attack_Power', f\"Loss_power{attack_power_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Attack_Power', f\"Error_power{attack_power_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "10e5d9ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 0\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Loss_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Error_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "d9d9c44b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 1\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Loss_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Error_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "id": "172bbef1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAATd0lEQVR4nO3dbYwd133f8e/PlAQ9WIlck5INXskUQvbBNSzXWDANFMRSUQm0K1cJkBdUXRcobBAOLDBt0RTKGxtN3xQwULRbKyUIlxCM1hIK2IoFl9YDUDtK4roiKVGWqCduabm6ZipSj6ZCOiylf1/sZXJDLbmz5Fxe7tnvB1jsnZkz5/4HXP72zNmZuakqJEntes+0C5AkTZZBL0mNM+glqXEGvSQ1zqCXpMZdNO0CFrJ69epat27dtMuQpGVjz549r1TVmoW2XZBBv27dOnbv3j3tMiRp2Ujyk9Ntc+pGkhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGXZDX0UvShWZ2dpa5ublObYfDIQCDwaBz/+vXr2fr1q1nVdtiDHpJ6tmxY8emXcJfYdBLUgdLGW2fbDs7OzupcpbEOXpJapxBL0mNM+glqXGLztEn2QHcBhyqqo8ssP13gM+M9fe3gDVV9VqSF4EjwNvAiaqa6atwSVI3XUb09wCbTrexqr5SVR+rqo8Bvwv8YVW9Ntbk5tF2Q16SpmDRoK+qR4HXFms3cgdw7zlVJEnqVW9z9EkuZ37k/82x1QU8nGRPki19vZckqbs+r6P/NPAnp0zb3FhVB5NcDTyS5LnRGcK7jH4RbAG47rrreixLkla2Pq+62cwp0zZVdXD0/RBwP7DxdDtX1faqmqmqmTVrFvzYQ0nSWegl6JP8IvAJ4Ntj665IcuXJ18CtwNN9vJ8kqbsul1feC9wErE4yBL4MXAxQVdtGzX4DeLiq/mxs12uA+5OcfJ9vVNWD/ZUuSepi0aCvqjs6tLmH+cswx9cdAG4428IkSf3wzlhJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDVu0Q8HT7IDuA04VFUfWWD7TcC3gR+PVn2rqn5vtG0T8B+AVcDXqurf9lO2JJ272dlZ5ubmeu93//79AGzdurX3vgHWr1+/pL4XDXrgHuCrwNfP0OaPquq28RVJVgF3A7cAQ2BXkgeq6pnO1UnSBM3NzfH0k09y5SVdorC7EyfeBuAnz+7rtV+AI8dPLHmfRY+uqh5Nsu4s6tkIzFXVAYAk9wG3Awa9pAvGlZdcxMZr3jftMjp77OXXl7xPX3P0v5LkySTfTfK3R+vWAi+NtRmO1i0oyZYku5PsPnz4cE9lSZL6CPrHgQ9V1Q3AfwT+YLQ+C7St03VSVduraqaqZtasWdNDWZIk6CHoq+pnVfXW6PVO4OIkq5kfwV871nQAHDzX95MkLc05B32SDyTJ6PXGUZ+vAruADUmuT3IJsBl44FzfT5K0NF0ur7wXuAlYnWQIfBm4GKCqtgG/CfxWkhPAMWBzVRVwIsmdwEPMX165o6r6/xO0JOmMulx1c8ci27/K/OWXC23bCew8u9IkSX3wzlhJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDVu0aBPsiPJoSRPn2b7Z5L8aPT1gyQ3jG17MclTSfYm2d1n4ZKkbrqM6O8BNp1h+4+BT1TVR4F/A2w/ZfvNVfWxqpo5uxIlSefiosUaVNWjSdadYfsPxhZ/CAx6qEuS1JO+5+g/B3x3bLmAh5PsSbLlTDsm2ZJkd5Ldhw8f7rksSVq5Fh3Rd5XkZuaD/lfHVt9YVQeTXA08kuS5qnp0of2rajujaZ+ZmZnqqy5JWul6GdEn+SjwNeD2qnr15PqqOjj6fgi4H9jYx/tJkro756BPch3wLeCzVfXC2Porklx58jVwK7DglTuSpMlZdOomyb3ATcDqJEPgy8DFAFW1DfgS8H7g95MAnBhdYXMNcP9o3UXAN6rqwQkcgyTpDLpcdXPHIts/D3x+gfUHgBvevYck6XzyzlhJalxvV91I0nIzHA45cvwEj738+rRL6ezI8RMMh8Ml7eOIXpIa54he0oo1GAx4+8ibbLzmfdMupbPHXn6dwWBpDyBwRC9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjFg36JDuSHEry9Gm2J8lskrkkP0ry8bFtm5I8P9p2V5+FS5K66TKivwfYdIbtnwQ2jL62AP8JIMkq4O7R9g8DdyT58LkUK0laukWDvqoeBV47Q5Pbga/XvB8CVyX5ILARmKuqA1V1HLhv1FaSdB71MUe/FnhpbHk4Wne69QtKsiXJ7iS7Dx8+3ENZkiToJ+izwLo6w/oFVdX2qpqpqpk1a9b0UJYkCfr5cPAhcO3Y8gA4CFxymvWSpPOojxH9A8A/GV1983eBN6vqT4FdwIYk1ye5BNg8aitJOo8WHdEnuRe4CVidZAh8GbgYoKq2ATuBTwFzwFHgn462nUhyJ/AQsArYUVX7JnAMkqQzWDToq+qORbYX8MXTbNvJ/C8CSdKUeGesJDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNa6PDweXpGXryPETPPby6732efTE2wBcftGqXvuF+XqXyqCXtGKtX79+Iv3u378fgA9t2DCR/pdat0EvacXaunXrRPudnZ2dSP9L1WmOPsmmJM8nmUty1wLbfyfJ3tHX00neTvLXRtteTPLUaNvuvg9AknRmi47ok6wC7gZuAYbAriQPVNUzJ9tU1VeAr4zafxr451X12lg3N1fVK71WLknqpMuIfiMwV1UHquo4cB9w+xna3wHc20dxkqRz1yXo1wIvjS0PR+veJcnlwCbgm2OrC3g4yZ4kW073Jkm2JNmdZPfhw4c7lCVJ6qJL0GeBdXWatp8G/uSUaZsbq+rjwCeBLyb5tYV2rKrtVTVTVTNr1qzpUJYkqYsuQT8Erh1bHgAHT9N2M6dM21TVwdH3Q8D9zE8FSZLOky5BvwvYkOT6JJcwH+YPnNooyS8CnwC+PbbuiiRXnnwN3Ao83UfhkqRuFr3qpqpOJLkTeAhYBeyoqn1JvjDavm3U9DeAh6vqz8Z2vwa4P8nJ9/pGVT3Y5wFIks6s0w1TVbUT2HnKum2nLN8D3HPKugPADedUoSTpnPhQM0lqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxnYI+yaYkzyeZS3LXAttvSvJmkr2jry913VeSNFmLfjh4klXA3cAtwBDYleSBqnrmlKZ/VFW3neW+khowOzvL3Nxcp7bD4RCAwWDQqf369evZunXrWde2knUZ0W8E5qrqQFUdB+4Dbu/Y/7nsK6lhx44d49ixY9MuY0VYdEQPrAVeGlseAr+8QLtfSfIkcBD4l1W1bwn7SmrAUkbcJ9vOzs5OqhyNdAn6LLCuTll+HPhQVb2V5FPAHwAbOu47/ybJFmALwHXXXdehLElSF12mbobAtWPLA+ZH7X+hqn5WVW+NXu8ELk6yusu+Y31sr6qZqppZs2bNEg5BknQmXYJ+F7AhyfVJLgE2Aw+MN0jygSQZvd446vfVLvtKkiZr0ambqjqR5E7gIWAVsKOq9iX5wmj7NuA3gd9KcgI4BmyuqgIW3HdCxyJJWkCXOfqT0zE7T1m3bez1V4Gvdt1XknT+eGesJDXOoJekxnWaupGklW4pd/3u378fWNp9BZO889egl6SeXXbZZdMu4a8w6CWpg+X8nB3n6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zkcgSDqtpTzIa6nO5sFfXU3yAWHLkUEv6bTm5ubY99SzXHX51b33/c7xAPDT//1qr/2+cfRQr/21wKCXdEZXXX41N//NzdMuo7PvPXfftEu44DhHL0mNM+glqXGdgj7JpiTPJ5lLctcC2z+T5Eejrx8kuWFs24tJnkqyN8nuPouXJC1u0Tn6JKuAu4FbgCGwK8kDVfXMWLMfA5+oqteTfBLYDvzy2Pabq+qVHuuWJHXUZUS/EZirqgNVdRy4D7h9vEFV/aCqXh8t/hAY9FumJOlsdQn6tcBLY8vD0brT+Rzw3bHlAh5OsifJltPtlGRLkt1Jdh8+fLhDWZKkLrpcXpkF1tWCDZObmQ/6Xx1bfWNVHUxyNfBIkueq6tF3dVi1nfkpH2ZmZhbsX5K0dF1G9EPg2rHlAXDw1EZJPgp8Dbi9qv7iDoiqOjj6fgi4n/mpIEnSedJlRL8L2JDkeuCnwGbgH403SHId8C3gs1X1wtj6K4D3VNWR0etbgd/rq/iFLOWW7eFwCMBg0P1PCt5aLWm5WTToq+pEkjuBh4BVwI6q2pfkC6Pt24AvAe8Hfj8JwImqmgGuAe4frbsI+EZVPTiRIzkLx44dm3YJWmEmORCZxCBkOBzy5tEjy+pu0zeOHqKG/t8e1+kRCFW1E9h5yrptY68/D3x+gf0OADecun6SlvKDfrLt7OzspMqRzpoDEfXFZ90sM8ttRLhUrR/fchuIDAYD8uevLrtn3awdvH/aZVxQlkXQT+pRqZN8TCpMP1haHxFeKMe3HH8+p/2zqfNrWQT997//fQ6/8iqs6rncd94G4Imn9vXbL8DbJxgOh73/Z1puI8KlWo7HNzc3x3N79/KBnvs9eUncG3v39trv/+21Ny0HyyLoAVh1Ee9cvnxOx95ztN9nbOvCNRwOF76x5BxN6qe9+MtpL60MyyLoB4MBL//5Rfz8w7dNu5TOLn3mOwwG3cZ4y/HUH7qf/i/H43NqQy1ZFkEP8J6jr3HpM9/ptc/8/GcA1KW/0Gu/MF8vHU/m5+bmeOHpx7nuvW/3WsMl/2/+5P/nL+7qtV+A//PWqs5t5+bmeGLfE3BVz0W8M//tiZ8+0W+/byyt+WAw4LlX+n9m38lzwr5H9mFp9468cfTQRC6vfOvn84/Heu+l7+u13zeOHmLtxM6HlqdlEfTr16+fSL/79x8BYMMv9T27CvCBznUPh0NqAuf+11z+Tv+djlR1P/2f2DTBeyfTLSyt5kn9fB4enbFctWFDr/1eRfeaJ3VsAPv3vwbA2l/qN5TX8v6J1r0cLYugn9Qp9IXyxzwtby3/fE5y+upCOL6VYlkE/VIsZT74bOZ4JzF3OxgMeOGN/j/Q+OWj81M3kxjZJ91P/weDAYffnMATSd8afZ/AyH4pUxvSha65oF+Kyy67bNolAJM7PT4++kV26bp+T/0B/jrTP/0/+Yt6w9qej2/t5Gqe5EDEPyDrdJoL+uX4g97yqf94HZPqd9rHNykXykBEy19qEn8FPEczMzO1e7cfL7uQsxkRbuj4x7wLYUTY+vG1zn+/6UmyZ/QwyXdpbkSvv9T6iLD142ud/37njyN6SWrAmUb0XT5hSpK0jBn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ17oK8YSrJYeAn5+ntVgP9f2rEhcPjW948vuXrfB/bh6pqzUIbLsigP5+S7D7d3WQt8PiWN49v+bqQjs2pG0lqnEEvSY0z6GH7tAuYMI9vefP4lq8L5thW/By9JLXOEb0kNc6gl6TGreigT7IpyfNJ5pLcNe16+pRkR5JDSZ6edi2TkOTaJN9L8mySfUl+e9o19SXJpUkeS/Lk6Nj+9bRrmoQkq5I8keQ7066lb0leTPJUkr1Jpv4pSit2jj7JKuAF4BZgCOwC7qiqZ6ZaWE+S/BrwFvD1qvrItOvpW5IPAh+sqseTXAnsAX69hX+/JAGuqKq3klwM/DHw21X1wymX1qsk/wKYAX6hqm6bdj19SvIiMFNVF8TNYCt5RL8RmKuqA1V1HLgPuH3KNfWmqh4FXpt2HZNSVX9aVY+PXh8BngXWTreqftS8t0aLF4++mhqRJRkA/wD42rRrWQlWctCvBV4aWx7SSFCsNEnWAX8H+F9TLqU3o2mNvcAh4JGqaubYRv498K+Ad6Zcx6QU8HCSPUm2TLuYlRz0WWBdU6OmlSDJe4FvAv+sqn427Xr6UlVvV9XHgAGwMUkz029JbgMOVdWeadcyQTdW1ceBTwJfHE2lTs1KDvohcO3Y8gA4OKVadBZG89ffBP5rVX1r2vVMQlW9AXwf2DTdSnp1I/APR/PY9wF/L8l/mW5J/aqqg6Pvh4D7mZ8qnpqVHPS7gA1Jrk9yCbAZeGDKNamj0R8s/zPwbFX9u2nX06cka5JcNXp9GfD3geemWlSPqup3q2pQVeuY/3/3P6rqH0+5rN4kuWJ0gQBJrgBuBaZ69duKDfqqOgHcCTzE/B/y/ltV7ZtuVf1Jci/wP4G/kWSY5HPTrqlnNwKfZX40uHf09alpF9WTDwLfS/Ij5gckj1RVc5cgNuwa4I+TPAk8Bvz3qnpwmgWt2MsrJWmlWLEjeklaKQx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1Lj/D2jtQpgDrM5cAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 2\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Loss_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Error_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "id": "ee16fc28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = np.loadtxt(os.path.join('Sample_Complexity', 'Loss_N500'))\n",
    "data = data[:, :-1]\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "id": "228bbba9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 3\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Loss_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Error_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "a5e91ee3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 4\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Loss_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Sample_Complexity', f\"Error_N{N_train_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2de361aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*********************************************************\n",
      "Trial 1\n",
      "Time cost 3.6999521255493164\n",
      "Method SVM OGD\n",
      "Training samples 1000\n",
      "Time Cost 0.06500387191772461\n",
      "Loss 1.0836694526116781 Error 1.0859294662152639 Normalized Error 1.2053681412648827\n",
      "*********************************************************\n",
      "Trial 2\n",
      "Time cost 3.4948089122772217\n",
      "Method SVM OGD\n",
      "Training samples 1000\n",
      "Time Cost 0.06355476379394531\n",
      "Loss 1.333529194882512 Error 1.1139861226262462 Normalized Error 1.2817227296040534\n",
      "*********************************************************\n",
      "Trial 3\n",
      "Time cost 3.4894750118255615\n",
      "Method SVM OGD\n",
      "Training samples 1000\n",
      "Time Cost 0.06600213050842285\n",
      "Loss 0.3224817722222044 Error 0.968624193690609 Normalized Error 1.1966951492979678\n",
      "*********************************************************\n",
      "Trial 4\n",
      "Time cost 3.551055431365967\n",
      "Method SVM OGD\n",
      "Training samples 1000\n",
      "Time Cost 0.06404566764831543\n",
      "Loss 1.1145710659641723 Error 1.146740841065964 Normalized Error 1.2475662809536079\n",
      "*********************************************************\n",
      "Trial 5\n",
      "Time cost 3.5760104656219482\n",
      "Method SVM OGD\n",
      "Training samples 1000\n",
      "Time Cost 0.06600069999694824\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-da8eaba3adb0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     42\u001b[0m     \u001b[0mglobals\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"time_\"\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0malg\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mstart\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     43\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Time Cost\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mglobals\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"time_\"\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0malg\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 44\u001b[1;33m     globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = z_test, direct = False,\n\u001b[0m\u001b[0;32m     45\u001b[0m                                                                                                     Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n\u001b[0;32m     46\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Loss\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maverage\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mglobals\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"loss_\"\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0malg\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"Error\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maverage\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mglobals\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"error_\"\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0malg\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"Normalized Error\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maverage\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mglobals\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"norm_err_\"\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0malg\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\revised code\\LinearProgramMethod.py\u001b[0m in \u001b[0;36mComputeLoss\u001b[1;34m(A, b, c, z, direct, Theta, hat_c, solved, solution, benchmark)\u001b[0m\n\u001b[0;32m    114\u001b[0m     \u001b[0msolution_est\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mN_samples\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim_target\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfloat64\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    115\u001b[0m     \u001b[0msolver\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mSolver\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mA\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mest_c\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 116\u001b[1;33m     \u001b[1;32mfor\u001b[0m \u001b[0mresult\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mpo2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msolver\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mStoreLP\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mN_samples\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    117\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    118\u001b[0m         \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0m_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0m_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msolu_get\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\multiprocessing\\pool.py\u001b[0m in \u001b[0;36mmap\u001b[1;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[0;32m    362\u001b[0m         \u001b[1;32min\u001b[0m \u001b[0ma\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mthat\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mreturned\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    363\u001b[0m         '''\n\u001b[1;32m--> 364\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_map_async\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmapstar\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    365\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    366\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mstarmap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\multiprocessing\\pool.py\u001b[0m in \u001b[0;36mget\u001b[1;34m(self, timeout)\u001b[0m\n\u001b[0;32m    763\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    764\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 765\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    766\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mready\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    767\u001b[0m             \u001b[1;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\multiprocessing\\pool.py\u001b[0m in \u001b[0;36mwait\u001b[1;34m(self, timeout)\u001b[0m\n\u001b[0;32m    760\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    761\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mwait\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 762\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_event\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    763\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    764\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\threading.py\u001b[0m in \u001b[0;36mwait\u001b[1;34m(self, timeout)\u001b[0m\n\u001b[0;32m    556\u001b[0m             \u001b[0msignaled\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    557\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 558\u001b[1;33m                 \u001b[0msignaled\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    559\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    560\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\threading.py\u001b[0m in \u001b[0;36mwait\u001b[1;34m(self, timeout)\u001b[0m\n\u001b[0;32m    300\u001b[0m         \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m    \u001b[1;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    301\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 302\u001b[1;33m                 \u001b[0mwaiter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    303\u001b[0m                 \u001b[0mgotit\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    304\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "for trial in range(total_trial):\n",
    "    # Generate Fractional Knapsack Samples\n",
    "    benchmark = 1\n",
    "    dim_features = 5\n",
    "    dim_decision = 10\n",
    "    price = np.random.randint(low=1, high=1000, size=dim_decision)\n",
    "    lower = np.amax(price)\n",
    "    upper = (np.random.rand()-1)*lower + np.sum(price)\n",
    "    Budget = [(upper-lower)*np.random.rand() + lower]\n",
    "    Coeff_Mat = np.random.binomial(n=1, p=0.5, size = (dim_decision, dim_features))\n",
    "    Theta_true = -np.concatenate((Coeff_Mat, np.zeros((dim_decision+1, dim_features))), axis=0)\n",
    "    print(\"*********************************************************\")\n",
    "    print(\"Trial\", trial + 1)\n",
    "    \n",
    "    N_train = 1000\n",
    "    # N_valid = 200\n",
    "    N_test = 1000\n",
    "    degree = 1\n",
    "    additive_noise = 1.0\n",
    "    scale_noise_uni = 0.0\n",
    "    scale_noise_div = 0.1\n",
    "    attack_threshold = None\n",
    "    attack_power = 0.0\n",
    "    z_train, c_train, A_train, b_train = dg.GenerateFractionalKnapsack(N_samples=N_train, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "                                        degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)\n",
    "    # z_valid, c_valid, A_valid, b_valid = dg.GenerateFractionalKnapsack(N_samples=N_valid, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "    #                                     degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)\n",
    "    z_test, c_test, A_test, b_test = dg.GenerateFractionalKnapsack(N_samples=N_test, dim_features=dim_features, dim_decision=dim_decision, Coeff_Mat=Coeff_Mat, price=price, Budget=Budget,\n",
    "                                        degree=degree, additive_noise=additive_noise, scale_noise_uni=scale_noise_uni, scale_noise_div=scale_noise_div, attack_threshold = attack_threshold, attack_power = attack_power)\n",
    "    # Compute Optimal Solutions\n",
    "    start = time.time()\n",
    "    basic_train, nonb_train, solution_train = lpm.ComputeBasis(c=c_train, A=A_train, b=b_train)\n",
    "    #basic_valid, nonb_valid, solution_valid = lpm.ComputeBasis(c=c_valid, A=A_valid, b=b_valid)\n",
    "    basic_test, nonb_test, solution_test = lpm.ComputeBasis(c=c_test, A=A_test, b=b_test)\n",
    "    print(\"Time cost\", time.time() - start)\n",
    "    alg = 'SVMOGD'\n",
    "    print(\"Method SVM OGD\")\n",
    "    print(\"Training samples\", N_train)\n",
    "    start = time.time()\n",
    "    globals()[\"Theta_\"+alg] = lm.SVM_OGD(A = A_train, b = b_train, z = z_train, basic = basic_train, nonb = nonb_train,\n",
    "                                         step_size = 1e-2, radius = 1.1* np.linalg.norm(Coeff_Mat, 'f'), regular_const=1e-2)\n",
    "    globals()[\"time_\"+alg] = time.time() - start\n",
    "    print(\"Time Cost\", globals()[\"time_\"+alg])\n",
    "    globals()[\"loss_\"+alg], globals()[\"error_\"+alg], globals()[\"norm_err_\"+alg] = lpm.ComputeLoss(benchmark = benchmark,A = A_test, b = b_test, c = c_test, z = z_test, direct = False,\n",
    "                                                                                                    Theta = globals()[\"Theta_\"+alg], solved = True, solution = solution_test)\n",
    "    print(\"Loss\", np.average(globals()[\"loss_\"+alg]), \"Error\", np.average(globals()[\"error_\"+alg]), \"Normalized Error\", np.average(globals()[\"norm_err_\"+alg]))\n",
    "    mark = 0\n",
    "    for j in range(len(globals()[focus + \"_set\"])):\n",
    "        if globals()[focus] == globals()[focus + \"_set\"][j]:\n",
    "            mark = j\n",
    "    globals()[\"Loss_\" + alg][trial][mark] = np.average(globals()[\"loss_\" + alg])\n",
    "    globals()[\"Error_\" + alg][trial][mark] = np.average(globals()[\"error_\" + alg])\n",
    "    globals()[\"Norm_Err_\" + alg][trial][mark] = np.average(globals()[\"norm_err_\" + alg])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "716ac7be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.944507443916253\n"
     ]
    }
   ],
   "source": [
    "print(np.average(globals()[\"Loss_\" + alg][trial][mark]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "8d79718e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAATLElEQVR4nO3df4yd1X3n8fcHB2cNZYsaTwhicIxkqyqNAo1GTiqqBlYLslmybqX+YZRN1CSVlQrkdHfVFd0/Eu3uP5UiVVvv0iCLWCjaBrQSobW2mB/SZkvTLK3H1ITfyYhSMTKVBygkgBXk+Lt/3MerK3PH8wy+4+s5835JV3PvOed55vsI8ZnH5557T6oKSVK7Lph0AZKklWXQS1LjDHpJapxBL0mNM+glqXEfmHQBo2zcuLE2b9486TIkadU4fPjwq1U1NarvvAz6zZs3Mzs7O+kyJGnVSPIPi/U5dSNJjTPoJalxSwZ9kiuTfDfJc0meSfKVEWOSZG+SuSQ/SPKJob7tSV7o+u4Y9wVIks6szx39CeDfV9UvAZ8Cbkty9WljdgBbu8du4BsASdYBd3b9VwO3jjhWkrSClgz6qnqlqp7onv8EeA644rRhO4Fv1cDjwKVJLge2AXNV9WJVvQvc142VJJ0jy5qjT7IZ+BXgb07rugJ4eej1fNe2WPuoc+9OMptkdmFhYTllSZLOoHfQJ/k54H7g96rqx6d3jzikztD+3saqfVU1U1UzU1Mjl4JKkt6HXuvok1zIIOT/tKq+M2LIPHDl0Otp4CiwfpF2aU3au3cvc3NzvcbOz88DMD093Wv8li1b2LNnz/uuTe3qs+omwDeB56rqjxYZdgD4fLf65lPAm1X1CnAI2JrkqiTrgV3dWElLOH78OMePH590GWpAnzv664DPAU8lOdK1/UdgE0BV3QU8CNwMzAHvAF/o+k4kuR14GFgH7K+qZ8Z5AdJqspw77lNj9+7du1LlaI1YMuir6nuMnmsfHlPAbYv0PcjgD4EkaQL8ZKwkNc6gl6TGGfSS1DiDXpIaZ9BLUuPOy41HpNVkOR+CWo4f/ehHwPKWZPblh6vWFoNeOktzc3M8f+QIHxnzeU/9c/uNI0fGet5/HOvZtBoY9NIYfAT40pk/bnLe+Obor5tSw5yjl6TGGfSS1DinbqSzND8/z09YPVMirwBvdd+MqbXBO3pJapx39NJZmp6e5o1XX11Vb8Ze2vM77tUGg14ag39k/FM3r3U/PzTWsw5qvXTM59T5zaCXztKWLVtW5LwL3QemLt26daznvZSVq1nnJ4NeOksr9QlTNx7RuCwZ9En2A7cAx6rqYyP6fx/47ND5fgmYqqrXk7wE/AT4GXCiqmbGVbi0Gi3n6xKW+xUIfq2BFtNn1c09wPbFOqvq61V1bVVdC/wB8JdV9frQkBu6fkNeWoYNGzawYcOGSZehBvTZSvCxJJt7nu9W4N6zqkhqmHfcmoSxraNPchGDO//7h5oLeCTJ4SS7x/W7JEn9jfPN2M8Af33atM11VXU0yYeBR5M8X1WPjTq4+0OwG2DTpk1jLEuS1rZxfjJ2F6dN21TV0e7nMeABYNtiB1fVvqqaqaqZqampMZYlSWvbWII+yc8Dnwb+fKjt4iSXnHoO3AQ8PY7fJ0nqr8/yynuB64GNSeaBrwEXAlTVXd2w3wQeqaq3hw69DHggyanf8+2qemh8pUuS+uiz6ubWHmPuYbAMc7jtReCa91uYJGk8/PZKSWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1Ljlgz6JPuTHEsychvAJNcneTPJke7x1aG+7UleSDKX5I5xFi5J6qfPHf09wPYlxvxVVV3bPf4zQJJ1wJ3ADuBq4NYkV59NsZKk5Vsy6KvqMeD193HubcBcVb1YVe8C9wE738d5JElnYVxz9L+a5MkkB5P8ctd2BfDy0Jj5rk2SdA4tuTl4D08AH62qt5LcDPwZsBXIiLG12EmS7AZ2A2zatGkMZUmSYAx39FX146p6q3v+IHBhko0M7uCvHBo6DRw9w3n2VdVMVc1MTU2dbVmSpM5ZB32SjyRJ93xbd87XgEPA1iRXJVkP7AIOnO3vkyQtz5JTN0nuBa4HNiaZB74GXAhQVXcBvwX8bpITwHFgV1UVcCLJ7cDDwDpgf1U9syJXIUlaVAaZfH6ZmZmp2dnZSZchSatGksNVNTOqz0/GSlLjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIat2TQJ9mf5FiSpxfp/2ySH3SP7ye5ZqjvpSRPJTmSxJ1EJGkC+tzR3wNsP0P/3wOfrqqPA/8F2Hda/w1Vde1iO59IklbWknvGVtVjSTafof/7Qy8fB6bHUJckaUzGPUf/JeDg0OsCHklyOMnuMf8uSVIPS97R95XkBgZB/2tDzddV1dEkHwYeTfJ8VT22yPG7gd0AmzZtGldZkrTmjeWOPsnHgbuBnVX12qn2qjra/TwGPABsW+wcVbWvqmaqamZqamocZUmSGEPQJ9kEfAf4XFX9cKj94iSXnHoO3ASMXLkjSVo5S07dJLkXuB7YmGQe+BpwIUBV3QV8FfgQ8CdJAE50K2wuAx7o2j4AfLuqHlqBa5AknUGfVTe3LtH/O8DvjGh/EbjmvUdIks4lPxkrSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWrc2DYHl6TV5otf/CKvvPJKr7E//elPOXny5IrVcsEFF/DBD36w19jLL7+c/fv39z53n60E9wO3AMeq6mMj+gP8MXAz8A7w21X1RNe3vetbB9xdVX/YuzJJWmFvvPEGb7/99qTLAODkyZOcOHGi19g33nhjWefuc0d/D/DfgW8t0r8D2No9Pgl8A/hkknXAncCNwDxwKMmBqnp2WRVK0gq5/vrrmZub6zV2fn6e48ePr1gtGzZsYHp6utfYLVu2LOvcffaMfSzJ5jMM2Ql8q6oKeDzJpUkuBzYDc93esSS5rxtr0EurxN69ezl48GDv8e+88w6DKBi/JFx00UW9xu7YsYM9e/YsOa7PmBaM483YK4CXh17Pd22LtY+UZHeS2SSzCwsLYyhLkgTjeTM2I9rqDO0jVdU+YB/AzMzMytwSSFqWPXv2rJm73paNI+jngSuHXk8DR4H1i7RLks6hcUzdHAA+n4FPAW9W1SvAIWBrkquSrAd2dWMlSedQn+WV9wLXAxuTzANfAy4EqKq7gAcZLK2cY7C88gtd34kktwMPM1heub+qnlmBa5AknUGfVTe3LtFfwG2L9D3I4A+BJGlC/AoESWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjegV9ku1JXkgyl+SOEf2/n+RI93g6yc+S/ELX91KSp7q+2XFfgCTpzPpsJbgOuBO4kcFG4IeSHKiqZ0+NqaqvA1/vxn8G+LdV9frQaW6oqlfHWrkkqZc+d/TbgLmqerGq3gXuA3aeYfytwL3jKE6SdPb6BP0VwMtDr+e7tvdIchGwHbh/qLmAR5IcTrJ7sV+SZHeS2SSzCwsLPcqSJPXRJ+gzoq0WGfsZ4K9Pm7a5rqo+AewAbkvy66MOrKp9VTVTVTNTU1M9ypIk9dEn6OeBK4deTwNHFxm7i9OmbarqaPfzGPAAg6kgSdI50ifoDwFbk1yVZD2DMD9w+qAkPw98GvjzobaLk1xy6jlwE/D0OAqXJPWz5KqbqjqR5HbgYWAdsL+qnkny5a7/rm7obwKPVNXbQ4dfBjyQ5NTv+nZVPTTOC5AknVmqFptun5yZmZmanXXJvST1leRwVc2M6vOTsZLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxvUK+iTbk7yQZC7JHSP6r0/yZpIj3eOrfY+VJK2sJbcSTLIOuBO4kcFG4YeSHKiqZ08b+ldVdcv7PFaStEL63NFvA+aq6sWqehe4D9jZ8/xnc6wkaQz6BP0VwMtDr+e7ttP9apInkxxM8svLPJYku5PMJpldWFjoUZYkqY8+QZ8RbafvKP4E8NGqugb4b8CfLePYQWPVvqqaqaqZqampHmVJkvroE/TzwJVDr6eBo8MDqurHVfVW9/xB4MIkG/scK0laWX2C/hCwNclVSdYDu4ADwwOSfCRJuufbuvO+1udYSdLKWnLVTVWdSHI78DCwDthfVc8k+XLXfxfwW8DvJjkBHAd2VVUBI49doWuRJI2QQR6fX2ZmZmp2dnbSZUjSqpHkcFXNjOrzk7GS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMb1Cvok25O8kGQuyR0j+j+b5Afd4/tJrhnqeynJU0mOJHE3EUk6x5bcSjDJOuBO4EYGm30fSnKgqp4dGvb3wKer6p+S7AD2AZ8c6r+hql4dY92SpJ763NFvA+aq6sWqehe4D9g5PKCqvl9V/9S9fByYHm+ZkqT3q0/QXwG8PPR6vmtbzJeAg0OvC3gkyeEkuxc7KMnuJLNJZhcWFnqUJUnqY8mpGyAj2kbuKJ7kBgZB/2tDzddV1dEkHwYeTfJ8VT32nhNW7WMw5cPMzMz5t2O5JK1Sfe7o54Erh15PA0dPH5Tk48DdwM6qeu1Ue1Ud7X4eAx5gMBUkSTpH+gT9IWBrkquSrAd2AQeGByTZBHwH+FxV/XCo/eIkl5x6DtwEPD2u4iVJS1ty6qaqTiS5HXgYWAfsr6pnkny5678L+CrwIeBPkgCcqKoZ4DLgga7tA8C3q+qhFbkSSdJIqTr/psNnZmZqdtYl95LUV5LD3Q32e/jJWElqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMb12WFqVdm7dy9zc3O9xs7PzwMwPd1/i9stW7awZ8+e91WbJE3Cqgj6vXv3cvDgwaUHAu+88w7L/erlV199tffYJ598snctO3bs8I+CpIlbFUG/HOvWrePkyZO9xp4ad8EF/WewljNWks4HvTYeSbId+GMGO0zdXVV/eFp/uv6bgXeA366qJ/ocO4obj0jS8pzVxiNJ1gF3AjuAq4Fbk1x92rAdwNbusRv4xjKOlSStoD5TN9uAuap6ESDJfcBO4NmhMTuBb9XgnwePJ7k0yeXA5h7Hrnkr/R5EX0m46KKLeo/v+x7Earw+319RS/pMOF8BvDz0er5r6zOmz7EAJNmdZDbJ7MLCQo+yJEl99Lmjz4i202+5FhvT59hBY9U+YB8M5uh71NWMPXv2NH332Pr1See7PkE/D1w59HoaONpzzPoex0qSVlCfqZtDwNYkVyVZD+wCDpw25gDw+Qx8Cnizql7peawkaQUteUdfVSeS3A48zGCJ5P6qeibJl7v+u4AHGSytnGOwvPILZzp2Ra5EkjRSr3X055rr6CVpec5qHb0kaXUz6CWpcQa9JDXOoJekxp2Xb8YmWQD+4Rz9uo1A/+8pXn28vtXN61u9zvW1fbSqpkZ1nJdBfy4lmV3sneoWeH2rm9e3ep1P1+bUjSQ1zqCXpMYZ9N0XqTXM61vdvL7V67y5tjU/Ry9JrfOOXpIaZ9BLUuPWdNAn2Z7khSRzSe6YdD3jlGR/kmNJnp50LSshyZVJvpvkuSTPJPnKpGsalyT/LMnfJnmyu7b/NOmaVkKSdUn+Lsn/mnQt45bkpSRPJTmSZOLf0Lhm5+i7jct/CNzIYOOUQ8CtVdXEfrZJfh14i8Fevh+bdD3j1u1JfHlVPZHkEuAw8Bst/PdLEuDiqnoryYXA94CvVNXjEy5trJL8O2AG+OdVdcuk6xmnJC8BM1V1XnwYbC3f0f//Tc+r6l3g1MblTaiqx4DXJ13HSqmqV6rqie75T4DnWGQ/4tWmBt7qXl7YPZq6I0syDfwr4O5J17IWrOWg771xuc5vSTYDvwL8zYRLGZtuWuMIcAx4tKqaubbOfwX+A3BywnWslAIeSXI4ye5JF7OWg773xuU6fyX5OeB+4Peq6seTrmdcqupnVXUtg32WtyVpZvotyS3Asao6POlaVtB1VfUJYAdwWzeVOjFrOej7bHqu81g3f30/8KdV9Z1J17MSquoN4P8A2ydbyVhdB/zrbh77PuBfJPkfky1pvKrqaPfzGPAAg6niiVnLQe/G5atY94blN4HnquqPJl3POCWZSnJp93wD8C+B5yda1BhV1R9U1XRVbWbw/93/rqp/M+GyxibJxd0CAZJcDNwETHT125oN+qo6AZzauPw54H+2tHF5knuB/wv8YpL5JF+adE1jdh3wOQZ3g0e6x82TLmpMLge+m+QHDG5IHq2q5pYgNuwy4HtJngT+FviLqnpokgWt2eWVkrRWrNk7eklaKwx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1Lj/B47mAU5oBiTXAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 0\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Degree', f\"Loss_degree{degree_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Degree', f\"Error_degree{degree_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "a9d28726",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 1\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Degree', f\"Loss_degree{degree_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Degree', f\"Error_degree{degree_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "b14eb2ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 2\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Degree', f\"Loss_degree{degree_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Degree', f\"Error_degree{degree_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "a8ad342c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD7CAYAAABzGc+QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAASpElEQVR4nO3dYYhd5Z3H8d8vYyTRWBL1Godc0ywm7a4UGpchFAKL1bZkXan2RUGhkhdC+qKi0kKxpdAWutAXrS0DSyFdpdlttyLYorjdbkNqEKGrTsyoScc2tyW6V8fMqB2d2USzSf774p6R2clM7rl3zplznzvfDwz33jPnPud/cPzluec+53kcEQIApGdV1QUAALpDgANAoghwAEgUAQ4AiSLAASBRBDgAJCp3gNsesH3Y9hPZ68tt77d9LHvcUF6ZAID5OumB3ytpbM7r+yUdiIhtkg5krwEAy8R5buSxXZe0T9I/SvpyRNxi+w+SboiIcduDkg5GxEcv1M6VV14ZW7ZsKaBsAFg5Dh069GZE1OZvvyjn+38o6auSLpuzbWNEjEtSFuJXtWtky5YtGhkZyXlIAIAk2X5loe1tL6HYvkXSREQc6vLAe2yP2B6ZnJzspgkAwALyXAPfKemzto9LeljSjbZ/KulEdulE2ePEQm+OiL0RMRQRQ7XaeZ8AAABdahvgEfG1iKhHxBZJt0v6bUR8QdLjknZnu+2W9FhpVQIAzrOUceDflfRp28ckfTp7DQBYJnm/xJQkRcRBSQez529Juqn4kgAAeXAnJgAkigAHgER1dAkF5RkeHlaj0ci9f7PZlCTV6/Vc+2/dulX33HNPV7UB6E0EeKJOnTpVdQkAKkaA94hOe8ez+w8PD5dRTuE6+YTR6acLiU8YWJkIcPQcPl0A+RDgWBad9I5T+3QBVIVRKACQKAIcABJFgANAoghwAEgUAQ4AiSLAASBRBDgAJIoAB4BEEeAAkCgCHAASRYADQKLaBrjtNbaftf2C7aO2v51t/5bt12yPZj83l18uAGBWnsms3pd0Y0TM2F4t6Wnb/5H97gcR8b3yygMALKZtgEdESJrJXq7OfqLMogAA7eW6Bm57wPaopAlJ+yPimexXd9t+0fZDtjeUVSQA4Hy5AjwizkbEdkl1STtsf0zSjyRdK2m7pHFJ31/ovbb32B6xPTI5OVlI0QCADkehRMSUpIOSdkXEiSzYz0n6saQdi7xnb0QMRcRQrVZbar0AgEyeUSg12+uz52slfUrSy7YH5+z2OUlHSqkQALCgPKNQBiXtsz2gVuA/EhFP2P5X29vV+kLzuKQvllYlAOA8eUahvCjp+gW231lKRQCAXLgTEwASRYADQKIIcABIFAEOAIkiwAEgUQQ4ACSKAAeARBHgAJAoAhwAEkWAA0CiCHAASBQBDgCJIsABIFEEOAAkigAHgEQR4ACQKAIcABKVZ03MNbaftf2C7aO2v51tv9z2ftvHsscN5ZcLAJiVpwf+vqQbI+LjkrZL2mX7E5Lul3QgIrZJOpC9BgAsk7YBHi0z2cvV2U9IulXSvmz7Pkm3lVEgAGBhua6B2x6wPSppQtL+iHhG0saIGJek7PGq0qoEAJwnV4BHxNmI2C6pLmmH7Y/lPYDtPbZHbI9MTk52WSYAYL6ORqFExJSkg5J2STphe1CSsseJRd6zNyKGImKoVqstrVoAwAfyjEKp2V6fPV8r6VOSXpb0uKTd2W67JT1WUo0AgAVclGOfQUn7bA+oFfiPRMQTtn8n6RHbd0l6VdLnS6wTADBP2wCPiBclXb/A9rck3VRGUQCA9rgTEwASRYADQKIIcABIFAEOAIkiwAEgUQQ4ACSKAAeARBHgAJAoAhwAEkWAA0CiCHAASBQBDgCJIsABIFEEOAAkigAHgEQR4ACQKAIcABJFgANAovIsanyN7Sdtj9k+avvebPu3bL9mezT7ubn8cgEAs/IsanxG0lci4nnbl0k6ZHt/9rsfRMT3yisPALCYPIsaj0saz55P2x6TtKnswgAAF9bRNXDbW9Raof6ZbNPdtl+0/ZDtDUUXBwBYXO4At71O0qOS7ouIdyX9SNK1krar1UP//iLv22N7xPbI5OTk0isGAEjKGeC2V6sV3j+LiF9IUkSciIizEXFO0o8l7VjovRGxNyKGImKoVqsVVTcArHh5RqFY0oOSxiLigTnbB+fs9jlJR4ovDwCwmDyjUHZKulPSS7ZHs21fl3SH7e2SQtJxSV8soT4AwCLyjEJ5WpIX+NWvii8HAJBXnh44sKDh4WE1Go3C2z127Jgk6Z577im8bUnaunVraW0Dy4kAL1FZASeVG3J5A67RaOjw0cPS+oILONd6OPza4YIbljRVfJNAVQjwEjUaDf3xyPPavO5s4W1f/L+t75/fO/5coe2+OjPQ2RvWS+duOFdoDWVadZDpf9A/CPCSbV53Vt8Ymqm6jNy+M7Ku6hIA5ER3BAASRYADQKIIcABIFAEOAIkiwAEgUQQ4ACSKAAeARBHgAJAoAhwAEkWAA0CiCHAASBQBDgCJIsABIFF51sS8xvaTtsdsH7V9b7b9ctv7bR/LHjeUXy4AYFaeHvgZSV+JiL+R9AlJX7J9naT7JR2IiG2SDmSvAQDLpG2AR8R4RDyfPZ+WNCZpk6RbJe3Ldtsn6baSagQALKCja+C2t0i6XtIzkjZGxLjUCnlJVxVeHQBgUblX5LG9TtKjku6LiHfthRaqX/B9eyTtkaTNmzd3U+MHOlljstlsSpLq9Xqu/VnoFkBqcvXAba9WK7x/FhG/yDafsD2Y/X5Q0sRC742IvRExFBFDtVqtiJpzOXXqlE6dOrVsxwOA5da2B+5WV/tBSWMR8cCcXz0uabek72aPj5VS4Ryd9JBn9x0eHi6rHACoVJ5LKDsl3SnpJduj2bavqxXcj9i+S9Krkj5fSoUAgAW1DfCIeFrSYhe8byq2HABAXtyJCQCJIsABIFEEOAAkigAHgEQR4ACQKAIcABJFgANAoghwAEhU7smsAKxcTCTXmwhwAIViErnlQ4ADaIuJ5HoT18ABIFEEOAAkigAHgERxDbxEzWZT/zM9oO+MrKu6lNxemR7QpdkoAgC9jQBH15rNpvSOtOpgQh/kpqRm8A8U+gMBXqJ6va73zozrG0MzVZeS23dG1mlNzvG7AKpFgKNr9Xpdk57UuRvOVV1KbqsOrlJ9E/9AoT+0/exr+yHbE7aPzNn2Lduv2R7Nfm4ut0wAwHx5Ll7+RNKuBbb/ICK2Zz+/KrYsAEA7bQM8Ip6S9PYy1AIA6MBShg/cbfvF7BLLhsIqAgDk0m2A/0jStZK2SxqX9P3FdrS9x/aI7ZHJyckuDwcAmK+rAI+IExFxNiLOSfqxpB0X2HdvRAxFxFCtVuu2TgDAPF0FuO3BOS8/J+nIYvsCAMrRdhy47Z9LukHSlbabkr4p6Qbb2yWFpOOSvlheiQDK0MkiDZ04duyYpM6moM2LxR/+v7YBHhF3LLD5wRJqAbCMGo2Gjr40pvWXXFVou+dOW5L02p/eKrTdqZMThbbXDyq/E5NeAFCd9ZdcpU/+9e1Vl5HLky8/XHUJPafyAG80Gjr80u917pLLC23Xp0OSdOhPbxTa7qqTDIkH0BsqD3BJOnfJ5XrvuluqLiOXNb9/ouoSAEASCzoAQLIIcABIFAEOAIkiwAEgUT3xJWY/e3WmnDUxT5xs/du78ZJiF1N4dWZAH+nkDVMlLKk2u4BRGUuJTknaVEK7SFonw5mb2Zqx9ZwrV5U57JgAL9HWrVtLa/t0Ns59zZZthbb7EeWvu6zzmx3Dv21TsecmSdpU7n8X9L9Tp05VXcIHCPASlXmzz2zbw8PDpR0jbw1ltVvluWFl6eRvuZf+PrkGDgCJIsABIFEEOAAkqvJr4M1mU6tOvpPMLeqrTr6lZvNM1WUAS9ZsNvXOyelkJomaOjmhaPbOF4i9gB44ACSq8h54vV7XifcvSmoyq3r96qrLAJasXq/L77+V1HSym+pXVF1GT6EHDgCJahvgth+yPWH7yJxtl9veb/tY9rih3DIBAPPl6YH/RNKuedvul3QgIrZJOpC9BgAso7YBHhFPSZq/DM2tkvZlz/dJuq3YsgAA7XR7DXxjRIxLUvZY7KqoAIC2Sv8S0/Ye2yO2RyYnJ8s+HACsGN0G+Anbg5KUPU4stmNE7I2IoYgYqtVqXR4OADBftwH+uKTd2fPdkh4rphwAQF5tb+Sx/XNJN0i60nZT0jclfVfSI7bvkvSqpM8vpYhVJ98u/FZ6v/euJCnWfKjQdledfFsSN/IAva6TRRo6MTtffRnTKXe6+EPbAI+IOxb51U25j3IB5S0KMC1J2nZt0WF7NQsC4DyprujSzxqNho688IIuu7jYG87PnDkrSXpl7Gih7U6f7nyOpcpvpWdRgJZOewud9gKqDoFOzq+bHk7V59eJXlrRZerkROGTWc289xdJ0ro1xd7fN3VyQpvU2a30l118kXZsTOM+w2dP/KXj91Qe4OjO2rVrqy6hNCmeW4orupT36bd128ima4udt2STruDT7zwEeI9IpffYrX4/vxTx6Td9TGYFAIkiwAEgUQQ4ACSKAAeARBHgAJAoAhwAEkWAA0CiCHAASBQBDgCJ4k5MAG2VOZdNWfPYNJtNTZ8+09UcI1WYPn3mg4nO8koqwFP8I0K6UpyOVKr+bznFuWxSlVSAd4I/IixVo9HQy6Ojhc/+Pnvdcmp0tOCWpTcKb7Elxc5NvV7X2el3kpqNMO8Uw7OSCvAU/4iQtqsl3SVXXUZuDyqqLgHLiC8xASBRSfXAAaATZXyJeTJbkeeSiwYKbXfZV+SxfVzStKSzks5ExNBS2gOAopS3YEXrS+gPb9tWeNud1lxED/yTEfFmAe0AQGFWwoIVXEIBFtFsNjWttL4YHJc00+FYYqRrqV9ihqTf2D5ke08RBQEA8llqD3xnRLxu+ypJ+22/HBFPzd0hC/Y9krR58+YlHg5YPvV6XVNvvpncMML1HY4lRrqW1AOPiNezxwlJv5S0Y4F99kbEUEQM1Wq1pRwOADBH1wFu+1Lbl80+l/QZSUeKKgwAcGFLuYSyUdIvbc+2828R8etCqgJ6xBsq/kvMt7LHKwptteUNSetLaBe9qesAj4g/S/p4gbUAPaWsccST2Tji9SWMI16v8upG72EYIbCIlTCOGGljLhQASBQBDgCJIsABIFEEOAAkigAHgEQR4ACQKAIcABJFgANAoghwAEgUAQ4AieJWegAr3vDwsBqNRq59Z9fEzDvVwtatW0ubloEAB4AOrF27tuoSPkCAA1jxyuohl40ABwqQ6kdwpI0AB5ZZL30ER9oIcKAA9JBRhSUNI7S9y/YfbDds319UUQCA9payqPGApH+S9PeSrpN0h+3riioMAHBhS+mB75DUiIg/R8RpSQ9LurWYsgAA7SwlwDdJ+u85r5vZNgDAMlhKgHuBbXHeTvYe2yO2RyYnJ5dwOADAXEsJ8Kaka+a8rkt6ff5OEbE3IoYiYqhWqy3hcACAuZYS4M9J2mb7r2xfLOl2SY8XUxYAoJ2ux4FHxBnbd0v6T0kDkh6KiKOFVQYAuCBHnHfZuryD2ZOSXlm2A0pXSnpzGY+33Pr5/Pr53CTOL3XLfX4fjojzrkEva4AvN9sjETFUdR1l6efz6+dzkzi/1PXK+bGgAwAkigAHgET1e4DvrbqAkvXz+fXzuUmcX+p64vz6+ho4APSzfu+BA0Df6ssA7/dpbm0/ZHvC9pGqayma7WtsP2l7zPZR2/dWXVORbK+x/aztF7Lz+3bVNRXN9oDtw7afqLqWotk+bvsl26O2Ryqvp98uoWTT3P5R0qfVut3/OUl3RMTvKy2sQLb/TtKMpH+JiI9VXU+RbA9KGoyI521fJumQpNv65b+fbUu6NCJmbK+W9LSkeyPivyourTC2vyxpSNKHIuKWquspku3jkoYioifGuPdjD7zvp7mNiKckvV11HWWIiPGIeD57Pi1pTH00y2W0zGQvV2c/fdOLsl2X9A+S/rnqWlaCfgxwprntE7a3SLpe0jMVl1Ko7BLDqKQJSfsjop/O74eSvirpXMV1lCUk/cb2Idt7qi6mHwM81zS36G2210l6VNJ9EfFu1fUUKSLORsR2tWbw3GG7Ly6D2b5F0kREHKq6lhLtjIi/VWslsi9llzMr048BnmuaW/Su7Nrwo5J+FhG/qLqeskTElKSDknZVW0lhdkr6bHad+GFJN9r+abUlFSsiXs8eJyT9Uq1LtpXpxwBnmtuEZV/yPShpLCIeqLqeotmu2V6fPV8r6VOSXq60qIJExNcioh4RW9T6/+63EfGFissqjO1Lsy/WZftSSZ+RVOlIsL4L8Ig4I2l2mtsxSY/02zS3tn8u6XeSPmq7afuuqmsq0E5Jd6rVexvNfm6uuqgCDUp60vaLanU29kdE3w2361MbJT1t+wVJz0r694j4dZUF9d0wQgBYKfquBw4AKwUBDgCJIsABIFEEOAAkigAHgEQR4ACQKAIcABJFgANAov4PfC+mkQ5sSicAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 3\n",
    "data = np.array([Reg_RF.T[i], Reg_OLS.T[i], Reg_Ridge.T[i], Reg_ML.T[i], Reg_SPO.T[i], Reg_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Degree', f\"Loss_degree{degree_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()\n",
    "\n",
    "data = np.array([Err_RF.T[i], Err_OLS.T[i], Err_Ridge.T[i], Err_ML.T[i], Err_SPO.T[i], Err_SVMOGD.T[i]]).T\n",
    "np.savetxt(os.path.join('Degree', f\"Error_degree{degree_set[i]}\"), data)\n",
    "sns.boxplot(data = data, showfliers = False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "c1d764b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(os.path.join('Sample_Complexity', \"RegretSP_N\"), [Reg_RF[0], Reg_ML[0], Reg_Ridge[0], Reg_OLS[0], Reg_SPO[0], Reg_NOGD[0], Reg_SVMOGD[0]])\n",
    "np.savetxt(os.path.join('Sample_Complexity', \"ErrorSP_N\"), [Err_RF[0], Err_ML[0], Err_Ridge[0], Err_OLS[0], Err_SPO[0], Err_NOGD[0], Err_SVMOGD[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "ffa80c91",
   "metadata": {},
   "outputs": [],
   "source": [
    "N_set = [100, 200, 500, 1000, 2000, 5000]\n",
    "for N in N_set:\n",
    "    [globals()[f\"Regret_RF_{N}\"], globals()[f\"Regret_ML_{N}\"], globals()[f\"Regret_Ridge_{N}\"],\n",
    "     globals()[f\"Regret_OLS_{N}\"], globals()[f\"Regret_SPO_{N}\"], globals()[f\"Regret_NOGD_{N}\"], \n",
    "     globals()[f\"Regret_SVMOGD_{N}\"]] = np.loadtxt(os.path.join('Sample_Complexity', \"RegretFK_N{}\".format(N)))\n",
    "    [globals()[f\"Error_RF_{N}\"], globals()[f\"Error_ML_{N}\"], globals()[f\"Error_Ridge_{N}\"],\n",
    "     globals()[f\"Error_OLS_{N}\"], globals()[f\"Error_SPO_{N}\"], globals()[f\"Error_NOGD_{N}\"],\n",
    "     globals()[f\"Error_SVMOGD_{N}\"]] = np.loadtxt(os.path.join('Sample_Complexity', \"ErrorFK_N{}\".format(N)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "64820d12",
   "metadata": {},
   "outputs": [],
   "source": [
    "regret = []\n",
    "error = []\n",
    "columns = []\n",
    "for N in N_set:\n",
    "    regret = regret + [globals()[f\"Regret_RF_{N}\"], globals()[f\"Regret_Ridge_{N}\"], globals()[f\"Regret_OLS_{N}\"],\n",
    "                              globals()[f\"Regret_ML_{N}\"], globals()[f\"Regret_SPO_{N}\"], globals()[f\"Regret_NOGD_{N}\"], \n",
    "                              globals()[f\"Regret_SVMOGD_{N}\"]]\n",
    "    error = error + [globals()[f\"Error_RF_{N}\"], globals()[f\"Error_Ridge_{N}\"], globals()[f\"Error_OLS_{N}\"],\n",
    "                              globals()[f\"Error_ML_{N}\"], globals()[f\"Error_SPO_{N}\"], globals()[f\"Error_NOGD_{N}\"], \n",
    "                              globals()[f\"Error_SVMOGD_{N}\"]]\n",
    "    columns = columns + [f\"RF, {N}\", f\"Ridge, {N}\", f\"OLS, {N}\", f\"ML, {N}\", f\"SPO, {N}\", f\"NOGD, {N}\", f\"SVMOGD, {N}\"]\n",
    "data_reg = pd.DataFrame(np.array(regret).T, columns = columns)\n",
    "data_err = pd.DataFrame(np.array(error).T, columns = columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "d09a4615",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_reg, showfliers=False)\n",
    "xticks = []\n",
    "xticklabels = []\n",
    "for i in range(len(N_set)):\n",
    "    xticks.append(int(len(methods)/2) + i * len(methods))\n",
    "    xticklabels.append(f'{N_set[i]}')\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "617239c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_err, showfliers=False)\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "c8222f9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dim_set = [6, 8, 10, 12, 14]\n",
    "for dim in dim_set:\n",
    "    [globals()[f\"Regret_RF_{dim}\"], globals()[f\"Regret_ML_{dim}\"], globals()[f\"Regret_Ridge_{dim}\"],\n",
    "     globals()[f\"Regret_OLS_{dim}\"], globals()[f\"Regret_SPO_{dim}\"], globals()[f\"Regret_NOGD_{dim}\"], \n",
    "     globals()[f\"Regret_SVMOGD_{dim}\"]] = np.loadtxt(os.path.join('Problem_Size', \"RegretFK_dim{}\".format(dim)))\n",
    "    [globals()[f\"Error_RF_{dim}\"], globals()[f\"Error_ML_{dim}\"], globals()[f\"Error_Ridge_{dim}\"],\n",
    "     globals()[f\"Error_OLS_{dim}\"], globals()[f\"Error_SPO_{dim}\"], globals()[f\"Error_NOGD_{dim}\"],\n",
    "     globals()[f\"Error_SVMOGD_{dim}\"]] = np.loadtxt(os.path.join('Problem_Size', \"ErrorFK_dim{}\".format(dim)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "feda1d15",
   "metadata": {},
   "outputs": [],
   "source": [
    "regret = []\n",
    "error = []\n",
    "columns = []\n",
    "for dim in dim_set:\n",
    "    regret = regret + [globals()[f\"Regret_RF_{dim}\"], globals()[f\"Regret_Ridge_{dim}\"],\n",
    "                 globals()[f\"Regret_OLS_{dim}\"], globals()[f\"Regret_ML_{dim}\"], globals()[f\"Regret_SPO_{dim}\"], globals()[f\"Regret_NOGD_{dim}\"], \n",
    "                 globals()[f\"Regret_SVMOGD_{dim}\"]]\n",
    "    error = error + [globals()[f\"Error_RF_{dim}\"], globals()[f\"Error_Ridge_{dim}\"],\n",
    "                 globals()[f\"Error_OLS_{dim}\"], globals()[f\"Error_ML_{dim}\"], globals()[f\"Error_SPO_{dim}\"], globals()[f\"Error_NOGD_{dim}\"],\n",
    "                 globals()[f\"Error_SVMOGD_{dim}\"]]\n",
    "    columns = columns + [f\"RF, {dim}\", f\"Ridge, {dim}\", f\"OLS, {dim}\", f\"ML, {dim}\", f\"SPO, {dim}\", f\"NOGD, {dim}\", f\"SVMOGD, {dim}\"]\n",
    "data_reg = pd.DataFrame(np.array(regret).T, columns = columns)\n",
    "data_err = pd.DataFrame(np.array(error).T, columns = columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "id": "bfa89c9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAAI/CAYAAADgJsn+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAvkklEQVR4nO3db4yl130f9u/Zv17S2xUVLk3dFVe0L8i0sNBY7oKyGrkQUguVBSFqAb1QooaOW4DwwFaTIoOySQCnyYvWRAcpHCkYVrAVmQAhw3BUWwioJEIQwyZQaUUxFClS5kpXTsjlI3opiloNuaP9x9MXM5uudmdm7529z9yZOZ8PMNh773Oe5/yGnGfmPt97nnNKrTUAAAAA7G57Zl0AAAAAAP0TAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRg36w6vv322+vdd989q+4BAAAAdp2vfvWr3621Hl1r28xCoLvvvjtPPPHErLoHAAAA2HVKKf9hvW1uBwMAAABowA1DoFLKj5VSTpZSvlZKebaU8g/XaPO+UsrZUspTq1+/3k+5AAAAAGzGOLeDnU/yV2qtr5dS9id5vJTyhVrrl65p9ye11g9Nv0QAAAAAbtYNQ6Baa03y+urT/atftc+iAAAAAJiuseYEKqXsLaU8leRMki/WWr+8RrP3rN4y9oVSyk9Ps0gAAAAAbs5YIVCt9XKt9WeSvD3JfaWUd17T5Mkk76i1/qUkn0jyB2sdp5TyQCnliVLKE6+88srmqwYAAABgIhOtDlZr/X6SP0rygWte/0Gt9fXVx48l2V9KuX2N/T9Vaz1Raz1x9OiaS9YDAAAA0INxVgc7Wkp5y+rjQ0l+IcmfXtPmzlJKWX183+pxX516tQAAAABsyjirg70tye+UUvZmJdz5vVrrvyil/EqS1FofTvKRJHOllEtJlpN8dHVCaQAAAAC2gXFWB3s6ybvWeP3hqx5/Msknp1saAAAAANMy0ZxAAAAAAOxMQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAFCIAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAaIAQCAAAAaMC+WRcAAAAAsJUWFxczGo2ue73ruiTJYDBYc7/hcJi5ublea+uTEAgAAAAgyfLy8qxL6JUQCAAAAGjKeqN55ufnkyQLCwtbWc6WMScQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANuGEIVEr5sVLKyVLK10opz5ZS/uEabUop5Z+UUr5VSnm6lPKz/ZQLAAAAwGbsG6PN+SR/pdb6eillf5LHSylfqLV+6ao2v5jkntWvdydZXP0XAAAAgG3ghiOB6orXV5/uX/2q1zT7cJJHVtt+KclbSilvm26pAAAAAGzWWHMClVL2llKeSnImyRdrrV++psmxJC9e9fz06msAAAAAbANjhUC11su11p9J8vYk95VS3nlNk7LWbte+UEp5oJTyRCnliVdeeWXiYgEAAADYnIlWB6u1fj/JHyX5wDWbTie566rnb0/SrbH/p2qtJ2qtJ44ePTpZpQAAAABs2jirgx0tpbxl9fGhJL+Q5E+vafb5JPevrhL2c0nO1lq/M+1iAQAAANiccVYHe1uS3yml7M1KaPR7tdZ/UUr5lSSptT6c5LEkH0zyrSTnkvxyT/UCAAAAsAk3DIFqrU8nedcarz981eOa5FenWxoAAAAA0zLRnEAAAAAA7Ezj3A4GAABADxYXFzMaja57vetW1tkZDAZr7jccDjM3NzeT/qfVN7D1hEAAAADbzPLyctP9A/0QAgEAAMzIeiNq5ufnkyQLCwu7un9ga5kTCAAAAKABQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAFCIAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAftmXQAAAABAHxYXFzMajcZuf6Xt/Pz8RP0Mh8PMzc1NtM8sCIEAAACAXWk0GuW5Z57O4b1lrPaXLtckyYvPPTN2H0ur++wEQiAAAABg1zq8t+S+w/t7O/7JpYu9HXvazAkEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANGDfrAsAAGD2FhcXMxqNrnu967okyWAwuG7bcDjM3Nxc77UBANMhBAIAYF3Ly8uzLgF2vPVC1o1caT8/Pz/RfsJZYCNCIAAA1r1ovHIBurCwsJXlwK4yGo3y3DNP5/DeMvY+ly7XJMmLzz0z9j5Lq/sArEcIBAAA0LPDe0vuO7y/1z5OLl3s9fjAzmdiaAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAaIAQCAAAAaIAQCAAAAKABQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAE3DIFKKXeVUv5tKeUbpZRnSyl/a4027yulnC2lPLX69ev9lAsAAADAZuwbo82lJH+n1vpkKeVwkq+WUr5Ya33umnZ/Umv90PRLBAAAAOBm3XAkUK31O7XWJ1cfLyX5RpJjfRcGAAAAwPRMNCdQKeXuJO9K8uU1Nr+nlPK1UsoXSik/PY3iAAAAAJiOcW4HS5KUUn48yT9P8rdrrT+4ZvOTSd5Ra329lPLBJH+Q5J41jvFAkgeS5Pjx45utGQAAAIAJjTUSqJSyPysB0KO11s9du73W+oNa6+urjx9Lsr+Ucvsa7T5Vaz1Raz1x9OjRmywdAAAAgHGNszpYSfLbSb5Ra/3H67S5c7VdSin3rR731WkWCgAAAMDmjXM72F9O8jeSPFNKeWr1tb+X5HiS1FofTvKRJHOllEtJlpN8tNZap18uAAAAAJtxwxCo1vp4knKDNp9M8slpFQUAAADAdE20OhgAAAAAO5MQCAAAAKABQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAFCIAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAaIAQCAAAAaIAQCAAAAKABQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAFCIAAAAIAGCIEAAAAAGiAEAgAAAGjAvlkXAAAAANCHruuydKnm5NLF3vpYulTTdV1vx58mIRAAQCMWFxczGo0m2udK+/n5+Yn2Gw6HmZubm2gfAKBfQiAAgEaMRqM898zTOby3jL3Ppcs1SfLic8+Mvc/S6j4AMGuDwSCXv/9q7ju8v7c+Ti5dzGAw6O340yQEAgBoyOG9pdc3wkl6HXIPAGyeiaEBAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAaIAQCAAAAaIAQCAAAAKABQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAFCIAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAasG/WBQAAAOxmXddl6VLNyaWLvfazdKmm67pe+wB2NiOBAAAAABpgJBAAAECPBoNBLn//1dx3eH+v/ZxcupjBYNBrH8DOZiQQAAAAQAOMBII1LC4uZjQarbntyn3Wa33KMhwOMzc312ttAAAAsBlCIJjQ8vLyrEsAAACAiQmBYA0bjeaZn59PkiwsLGxVOQAAAHDTzAkEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADbhhCFRKuauU8m9LKd8opTxbSvlba7QppZR/Ukr5Vinl6VLKz/ZTLgAAAACbsW+MNpeS/J1a65OllMNJvlpK+WKt9bmr2vxikntWv96dZHH1XwAAAAC2gRuOBKq1fqfW+uTq46Uk30hy7JpmH07ySF3xpSRvKaW8berVAgAAALApE80JVEq5O8m7knz5mk3Hkrx41fPTuT4oAgAAAGBGxg6BSik/nuSfJ/nbtdYfXLt5jV3qGsd4oJTyRCnliVdeeWWySgEAAADYtLFCoFLK/qwEQI/WWj+3RpPTSe666vnbk3TXNqq1fqrWeqLWeuLo0aObqRcAAACATRhndbCS5LeTfKPW+o/Xafb5JPevrhL2c0nO1lq/M8U6AQAAALgJ46wO9peT/I0kz5RSnlp97e8lOZ4ktdaHkzyW5INJvpXkXJJfnnqlAAAAAGzaDUOgWuvjWXvOn6vb1CS/Oq2iAAAAAJiuiVYHAwAAAGBnGud2MAAAdoGu67J0qebk0sVe+1m6VNN1160RAgDMmJFAAAAAAA0wEggAoBGDwSCXv/9q7ju8v9d+Ti5dzGAw6LUPAGByRgIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAP2zboAAADatri4mNFotOa2ruuSJIPB4Lptw+Ewc3NzvdYGALuJEAgAgG1reXl51iUAwK4hBAIAYKY2Gs0zPz+fJFlYWNiqcgBg1zInEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANGDfrAuAWVpcXMxoNJponyvt5+fnx95nOBxmbm5uon4AAABgmoRANG00GuW5Z57O4b1l7H0uXa5Jkhefe2as9kur7QEAAGCWhEA07/DekvsO7+/t+CeXLvZ2bAAAABiXOYEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAaYGBq2ofWWru+6LkkyGAzW3M9S9AAAAKxHCAQ7yPLy8qxLAAAAYIcSAsE2tN5onvn5+STJwsLCVpYDAADALmBOIAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAaIAQCAAAAaIAQCAAAAKABQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAFCIAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAaIAQCAAAAaMC+WRcAAFcsLi5mNBqtua3ruiTJYDC4bttwOMzc3FyvtQEAwE4nBAJgR1heXp51CQAAsKMJgQDYNjYazTM/P58kWVhY2KpyAABgVzEnEAAAAEADjAQC4EesNy+POXkAAGBnEwIBMBZz8gAAwM4mBALgR6w3osecPAAAsLOZEwgAAACgAUIgAAAAgAa4HQwAAGAXW2/Rh41caX/ldvBxWSwCtrcbhkCllE8n+VCSM7XWd66x/X1J/jDJn62+9Lla6z+aYo0AAABs0mg0yjeffT7HD9059j4HLqzcNHL+22fH3ueF5Zcnrg3YWuOMBPpMkk8meWSDNn9Sa/3QVCoCAABgqo4fujMP3nt/r308dGqjS0ZgO7jhnEC11j9O8r0tqAUAAACAnkxrYuj3lFK+Vkr5Qinlp6d0TAAAAACmZBoTQz+Z5B211tdLKR9M8gdJ7lmrYSnlgSQPJMnx48en0DUAAAAA47jpkUC11h/UWl9fffxYkv2llNvXafupWuuJWuuJo0eP3mzXAAAAAIzppkOgUsqdpZSy+vi+1WO+erPHBQAAAGB6xlki/rNJ3pfk9lLK6ST/IMn+JKm1PpzkI0nmSimXkiwn+WittfZWMQAAAAATu2EIVGv9azfY/smsLCEPO07XdVm6VHNy6WJvfSxdqum6rrfjAwAAwDimtToYAAAAANvYNFYHgx1rMBjk8vdfzX2H9/fWx8mlixkMBr0dHwAAAMZhJBAAAABAA4RAAAAAAA1wOxgAAADAFlpcXMxoNLru9SuLCq03pchwOMzc3Nym+xUCAQAAAGwDy8vLvR5fCAQAAACwhdYbzTM/P58kWVhY6KVfcwIBAAAANEAIBAAAANAAt4MBAAAAW2pWEyO3TggEAAAAbAt9T4zcOiEQAAAAsKW2cmLkpcs1J5cujtX23OWaJLllb5no+DuFEAgAAADYlYbD4UTtr9yidteE+03az6wIgQAAAIBdadL5g/peon3WrA4GAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRg36wLAKA9i4uLGY1GE+1zpf38/PxE+w2Hw8zNzU20DwAA7EZCIAC23Gg0ynPPPJ3De8vY+1y6XJMkLz73zNj7LK3uAwAACIEAmJHDe0vuO7y/1z5OLl3s9fgAALCTmBMIAAAAoAFCIAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAaIAQCAAAAaIAQCAAAAKABQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAFCIAAAAIAGCIEAAAAAGrBv1gUA0J6u67J0qebk0sVe+1m6VNN1Xa99AADATmEkEAAAAEADjAQCYMsNBoNc/v6rue/w/l77Obl0MYPBoNc+AABgpzASCAAAAKABQiAAAACABgiBAAAAABogBAIAAABogBAIAAAAoAFCIAAAAIAGCIEAAAAAGiAEAgAAAGiAEAgAAACgAUIgAAAAgAYIgQAAAAAasG/WBQAAAOx2S5drTi5dHLv9ucs1SXLL3jJRHwAbEQIBAAD0aDgcTrzPaDRKktw14b6b6Qtoxw1DoFLKp5N8KMmZWus719hekvxmkg8mOZfkb9Zan5x2oQAAADvR3NzcxPvMz88nSRYWFqZdDtCwceYE+kySD2yw/ReT3LP69UCSxZsvCwAAAIBpuuFIoFrrH5dS7t6gyYeTPFJrrUm+VEp5SynlbbXW70yrSACma3Fx8T8OMx/XlfZXPpkc13A43NQnoAAAwHRNY06gY0levOr56dXXhEAA29RoNMpzX38+Rw7cMfY+ly+uTEz50qnXxt7n7IUzE9cGAFtpvQ9Guq5LkgwGgzX38yEHsBNNIwRaa7r6NaelL6U8kJVbxnL8+PEpdA3AZh05cEfeO/hYr3083j3a6/EBoC/Ly8uzLgFg6qYRAp1OctdVz9+epFurYa31U0k+lSQnTpywfiEAwBazTDX8qPVG85iYGdiNphECfT7Jr5VSfjfJu5OcNR8QAMD2Y5lqAGjbOEvEfzbJ+5LcXko5neQfJNmfJLXWh5M8lpXl4b+VlSXif7mvYgEA2DzLVANA28ZZHeyv3WB7TfKrU6sIAAAAgKnbM+sCAAAAAOifEAgAAACgAUIgAAAAgAYIgQAAAAAaIAQCAAAAaMANVwcDAKB/i4uLGY1G173edV2SZDAYXLdtOBxuatl3AKBNQiAAZmLpcs3JpYtjtz93uSZJbtlbJuoDdrrl5eVZlwAA7BJCIAC23HA4nHifKyMk7ppw3830BbOw3oie+fn5JMnCwsJWlgMA7EJCIAC23GZuX3EhDAAAN8fE0AAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA2wOhgAAFticXExo9Foon2utL+yQuC4hsPhplYiBIDdTAgEAMCWGI1G+eazz+f4oTvH3ufAhZWB6+e/fXbsfV5Yfnni2gCgBUIgAAC2zPFDd+bBe+/vtY+HTj3S6/EBYKcSAtG8pcs1J5cujt3+3OWaJLllbxn7+AAAADBrQiCaNhwOJ97nytwEd02w72b6AQAAgGkSAtG0zUwYeWViyoWFhWmXAwAAAL0RAgEAZP2Vq7quS5IMBoM197MKFQCwUwiBAAA2sLy8POsSAACmQggEAJD1bxF2GzAAsFvsmXUBAAAAAPRPCAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANMDqYDBDi4uLGY1GY7e/0vbKSjXjGg6H6656AwAAQBuEQDBDo9Eo33z2+Rw/dOdY7Q9cWBm8d/7bZ8fu44XllzdVGwAAALuLEAhm7PihO/Pgvff3dvyHTj3S27EBAADYOcwJBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADdg36wJgLYuLixmNRmtu67ouSTIYDK7bNhwOMzc312ttAABMz3rv+zZ6z5d43wewGUIgdpzl5eVZlwA7Xtd1OXt+KY93j/baz9nzZ1I65ywAk/OeD3aHjT7gX8uVtvPz8xP1s12D4e32/QuB2JY2+uG9cjIsLCxsVTkAAPRkvfd93vPB7jAajfLc15/PkQN3jNX+8sWSJHnp1Gtj93H2wplN1bYVRqNRvvns8zl+6M6x2h+4sDJrz/lvnx27jxeWXx67rRAIoEGDwSD19dfy3sHHeu3n8e7RDAa39doHAADb25EDd/T6vrPv0e036/ihO/Pgvff3dvyHTj0ydlsTQwMAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQgH2zLgAAAID+dF2XN84t5aFTj/TazwvnXs6t3Ru99gHcHCOBAAAAABpgJBAAAMAuNhgMcv6HZ/Pgvff32s9Dpx7JwcGRXvsAbo6RQAAAAAANGGskUCnlA0l+M8neJL9Va/2Na7a/L8kfJvmz1Zc+V2v9R9MrEwD6t7i4mNFotOa2ruuSrHyaeq3hcJi5ubleawMAgJt1wxColLI3yT9N8v4kp5N8pZTy+Vrrc9c0/ZNa64d6qBEAZm55eXnWJQAAwE0ZZyTQfUm+VWv9dpKUUn43yYeTXBsCAcCOttFonvn5+STJwsLCVpUDwBRtNNpzLVfaXvn9Py6jQ4HtbJwQ6FiSF696fjrJu9do955SyteSdEnma63PTqE+AACAmzYajfLc15/PkQN3jNX+8sWSJHnp1Gtj93H2wplN1QawVcYJgcoar9Vrnj+Z5B211tdLKR9M8gdJ7rnuQKU8kOSBJDl+/PhklQIAANyEIwfuyHsHH+vt+I93j/Z2bJg2cyG2aZzVwU4nueuq52/Pymif/6jW+oNa6+urjx9Lsr+Ucvu1B6q1fqrWeqLWeuLo0aM3UTYAAADQh+XlZfMh7lLjjAT6SpJ7Sik/meSlJB9N8tevblBKuTPJn9daaynlvqyES69Ou1gAAADg5pkLsU03DIFqrZdKKb+W5F9lZYn4T9dany2l/Mrq9oeTfCTJXCnlUpLlJB+ttV57yxgAY1hvaK5huQAAwM0YZyTQlVu8HrvmtYevevzJJJ+cbmkAXM2QXAAA4GaMFQIBsHXWG9FjWC4AAHAzxpkYGgAAAIAdTggEAAAA0AAhEAAAAEADzAkEALBF1lv9byNX2l+ZF2xcVg0EAK4lBAIA2CKj0SjPff35HDlwx9j7XL5YkiQvnXpt7H3OXjgzcW0AwO4nBAJg29holMRGoyGMeGAnOXLgjrx38LFe+3i8e7TX429W13V549xSHjr1SK/9vHDu5dzavdFrHwCwEwmBWNNGF2Jd1yVJBoPBddtciAF9OXTo0KxLAACAHU0IxMSWl5dnXQKwSwmRYXcbDAY5/8OzefDe+3vt56FTj+Tg4EivfQDATiQEYk0bXYhduRVjYWFhq8oBAAAAbpIl4gEAAAAaYCQQANAMS7QDwNbqui5nzy/1umjB2fNnUjrTloxDCAQANGM0GuWbTz2VYxcujL3Pvn0rb5fOnTw59j4vHTgwcW0AAH0TAgEATTl24UI+fuaVXvv4xB1Hez0+AOwUg8Eg9fXX8t7Bx3rr4/Hu0QwGt/V2/JvRdV3eOLeUh0490lsfL5x7Obd2b4zV1pxAAAAAAA0wEggAAOjdpHNymY8L2A0Gg0HO//BsHrz3/t76eOjUIzk4ODJWWyEQAADQu0nn5DIfF8D0CYEAAIAt0fecXObjAtiYOYEAAAAAGiAEAgAAAGiAEAgAAACgAeYEAgAA2OVeWH45D516ZOz2Z85/L0lyx8G3TtTHPRlvhSJgNoRAMENd1+WNc0sT/UGe1AvnXs6t3Ru9HR8AYCfoui5nzy/l8e7R3vo4e/5MSrfc2/E3azgcTrzPhdF3kyQHf2r8UOeeHJm4r8XFxYxGo+te77ouycry2tcaDoeZm5ubqB9ghRAIAABgF9tMYDI/P58kWVhYmHY5Y1le3n5hGuwGQiBmar3kfyNX2l/5wzSO7fppwWAwyPkfns2D997fWx8PnXokBweG5QIAbRsMBqmvv5b3Dj7WWx+Pd49mMLitt+PvRuu9R591CAW7lRCImRqNRnnu68/nyIE7xt7n8sWSJHnp1GtjtT974cymagMAAIDdRAjEzB05cEfvn8gAAABA6ywRDwAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0wMTQADRncXExo9Foon2utL+yZO04hsPhukvf0qau63L2/FLvixacPX8mpVvutQ8AYOcRAgE06uyFMxNdiL5x8bUkya37b5uoj2MZv/1WGY1G+eazz+f4oTvH3ufAhZXBs+e/fXas9i8sv7yp2oCtt1Ew3HVdkmQwGFy3TdALwE4jBAJo0HA4nHif0eh7SZJjw/FDnWO5bVN9bYXjh+7Mg/fe39vxHzr1SG/HZucaDAapr7+W9w4+1ms/j3ePZjDYfgHsTrS8bETVtHRdl9cPHMgn7jjaWx+nDxzIj68GdwBcTwgE0KDNfHJ95TaohYWFaZcDMFMb/U70uw+A3UQIBAAA9G4wGOTc6dP5+JlXeuvjE3cczS1r3LoHLdsOcyFOMg3BbpqCYDsSAgEAAMAuNRqN8s2nnsqxCxfG3mffvpWo4NzJk2O1f+nAgXW3TTo1wG6bgmC7EQIBAM3YijlJEvOSALC9HLtwofdReOuZdBoCt+H2SwgEMANbNSw3sXrNTmKFIgCA3eeF5ZfHXjTkzPmVkVB3HHzrRMe/J0fGaisEApiBrRiWm2w8NJedxQpF07EVc5Ik5iXZyCRvhJP+3wwD7Zr1hy+z7p+tMeltahdG302SHPyp8f+O3ZMjY/cjBAKYkb6H5SYbD81l+7FCEbvdZuZr6PvNMMBaZv3hy6z7Z3q22+1wQiAAALbEZj65FoACfZn1hy+z7p82CYEAAKBhLd2SYplqoHVCoMaZnBYAYLa2cwizm25JsUw1gBCoeSanBQDYvrYihGnllpTtNi8HwCwIgTA5LddZ7xPJjT6NTIz2AoDNaCWEAWD2hEDA2HbTkHAAAIDWbOsQyGgEmI31zh+fRrJbdF2XN84t5aFTj/TWxwvnXs6t3Ru9HR8AACa1rUOg9RiNAAAAADCZbR0CGY0AQB8Gg0HO//BsHrz3/t76eOjUIzk4ONLb8QF2opcOHBh7rshXVhcjOXrp0kTHv2dTldEnKxLD9rGtQyAAYOvM+jbsWfcP9GvSpdMvrf4+uGWC/e7ZRD/0bzQa5d89+6c5f2j8xWL2ry5e/KVvvzr2PgeX+13sBnYDIRCw7cz6QnAz/bsIZTeb9W3Ys+4fmA5LtLft/KGjOX3vR3rt4+2nfr/X4+9UXdfl9QlG4W3G6QMH8uOr75XZ3oRAG5j1heCs+4ftZtYXgtPsfyv+GCf+IDOZWd+GPev+AQB2OyHQJuymC9FZ67ouZ88v5fHu0d76OHv+TEq3e/6btWDWF4Kz7h/Y3c5eODPR3703Lr6WJLl1/20T9XEs47dvxVbNS+JDOWA7GQwGOXf6dD5+pr/b5T5xx9Hcss5ofbYXIdAGZn0hOOv+2RovLL889jLVZ85/L0lyx8G3TnT8e2Jy2u1mK/4YJ/4gw3azmblKRqOV3/3HhuOHOsdym3lR1rAV85KYkwSA7UwIxEwNBoPU11/Lewcf662Px7tHMxhsz09DJ32DfmH03STJwZ8aP9S5J0dcCABcZZLViZLprlC0mdEhPvyZrr7nJTEnCQDbmRAIZsgEidAmt6TMzmZCcSsUAexss16i3t99thMhEABsMbekzI6ROMzSrC8EZ90/zMpoNMro2SczvPXc2Pscunhw5cG//874/bxxy7r9P/WNp3LxtotjH2vvm3uTJF95+Stjtd//2v6xj03bhEDQsEnfDE7zExFonVtSoD1bcSG63kXolf5diNKq4a3nsvDOb/Tax/zX/7N1t1287WK+9/7v9db3W784/pyhtG3mIdCsh+ZByyYdjTDpSITEaAS2r0kmZU8mn5jdpOzAWvq+EN3oIjRxIQrQupmHQFsxJD5xIQrrMRqBFm1mrpZJJ2bfzpOyz3oU4Kz7B2BrdV2Xg+d+0Pv7woPnXknXne+1D9jpZh4CJf1fhCbrX4jOeiTSrPuHWZn1z/6s+2e2Wp8XZtJbUqY5L8KV/ie5JWXS21ESt6QAAKxlW4RAs9TCJGHJ+m+Gu67L6xMulbsZpw8cyI93Xa99sLO0fu7BrLklBYCtMhgM8sIPD27JB/+DwV/otY+d6qUJr/le2bcSFRy9dGns49+zqcrYas2HQMnunyQs8WaY7cm5B8BW2opbUtyOAmw3m7k9/dLqCPhbxtz3nk32w9YbKwQqpXwgyW8m2Zvkt2qtv3HN9rK6/YNJziX5m7XWJ6dcKz0YDAY5d/p0Pn6m3zmTPnHH0dwyGPTaBwAAwLW6rsvyG7fccJTqzRq9cUsOrXH3Q9d12X92f68fDu5/bX+6N9e+86L12+D5UTcMgUope5P80yTvT3I6yVdKKZ+vtT53VbNfzEr4d0+SdydZXP0XbujshTN5vHt07PZvXHwtSXLr/tvGPv6xjNcWtlLfw3Kv9GFo7vZjNALMxlbckrLR7ShbcSG63kXolf5neSEKwOyNMxLoviTfqrV+O0lKKb+b5MNJrg6BPpzkkVprTfKlUspbSilvq7WOP3EHTdrMkMHRaOX2nWPD8YKdY7nN0MR1uBCdna0YlpsYmsvaXIgC0JLBYJBc+PbWTEOwxt0Pg8EgL+15qfe58AZ3uvOCGxsnBDqW5MWrnp/O9aN81mpzLMkNQ6Cu63Lo9VczfGrxum2lXkqpdYwSf1QtJbX86Le2582La16Idl2X7/3gcP67L/8X1207/+aevFnLRH3vKTUH97x53evLl/fmresMDTzw6oH8xO/9xHXbyuWSTPrtl6TuvX6ncqms+2Z4rdEIr+zbl/N79kzYeXLwzTfXHKWw3miE9YYmbmblpmR6qzBt1P9GK0T13f+NVqfaTP973ryYg+d+9HbAaZ97a5n2uZesff5t13Nvo/9Pm/n5n+YKZJv5+dstK6Bt1bk/GAzy56/94LrX95//fvZcHn+y8ive3Ls/Fw++5UdfLKtvetexfHnvdROnT/vcO7TBPuVSuW7i9E2de8ma51+5NPn3sZW/e6fV/24597fy7+7B5Veu+/BjmufeweVXkqw9EmgwGGT02svXvd798GCWL++duP9Dey9n8GPXv79d79wfDAY5c/bMda/vXdqbPZcmf9/35r43c/nw5bH7X89OPPda739a516yufNvzb972fj8G63x4ce0z73RG7dkvY/e9r92/Ycf0zz39r+2P7lzsuO0dM2j///fOCHQWu+irn2LNk6blFIeSPJAkhw/fjxJcuTIkSwvL6/Z8fnzb+bNN68PVG5kz549OXjw2hV59ufIkSPXtd2o/5w/n0za/549ycGD1718aLWvSfo/f/78xN//nj17cvDA9f3nwNr9rzdCYH/X5dJ6/102sP/QoTXn/pnmaIRDhza6rOjfLPufdt8///M/v+Yvnq7r1j8vNnDo0KE13/it9f9+6udesub5t13Pvc1o+Wd/O5jm97/e78OuO59NnHqr5961b3r/wrr9zPLc3w79b+b4s6T/3XPurfsz2XXZZAHXjToYbtDPut//mzdx7l078uBO557+r7fRz8Rmzr+1z71kvfNvK869ZP3zb6ede1f6mJXd9LO/Hfsv9Qaf9pdS3pPkf6u1/jerz/9uktRa/4+r2vzfSf6o1vrZ1efPJ3nfRreDnThxoj7xxBM3/x0AAAAAkCQppXy11npirW3jjD37SpJ7Sik/WUo5kOSjST5/TZvPJ7m/rPi5JGfNBwQAAACwfdzwdrBa66VSyq8l+VdZWSL+07XWZ0spv7K6/eEkj2VlefhvZWWJ+F/ur2QAAAAAJjXOnECptT6WlaDn6tcevupxTfKr0y0NAAAAgGmZfCpyAAAAAHYcIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANAAIRAAAABAA4RAAAAAAA0QAgEAAAA0QAgEAAAA0AAhEAAAAEADhEAAAAAADRACAQAAADSg1Fpn03EpryT5DzPpnGm4Pcl3Z10ENMi5B7Ph3IPZcO7B7Dj/dq531FqPrrVhZiEQO1sp5Yla64lZ1wGtce7BbDj3YDacezA7zr/dye1gAAAAAA0QAgEAAAA0QAjEZn1q1gVAo5x7MBvOPZgN5x7MjvNvFzInEAAAAEADjAQCAAAAaIAQiImUUt5SSvn9UsqfllK+UUp5z6xrghaUUv7nUsqzpZSvl1I+W0r5sVnXBLtVKeXTpZQzpZSvX/XaW0spXyylfHP139tmWSPsRuuce//n6vvOp0sp/08p5S0zLBF2pbXOvau2zZdSainl9lnUxvQJgZjUbyb5l7XW/zTJX0ryjRnXA7teKeVYkv8pyYla6zuT7E3y0dlWBbvaZ5J84JrX/tck/6bWek+Sf7P6HJiuz+T6c++LSd5Za/3Pk5xK8ne3uihowGdy/bmXUspdSd6f5IWtLoj+CIEYWynlP0nyXyX57SSptV6otX5/pkVBO/YlOVRK2ZfkliTdjOuBXavW+sdJvnfNyx9O8jurj38nyX+7lTVBC9Y692qt/7rWemn16ZeSvH3LC4Ndbp2/e0nyfyX5X5KYSHgXEQIxiZ9K8kqSf1ZK+XellN8qpdw666Jgt6u1vpRkISufwnwnydla67+ebVXQnJ+otX4nSVb/vWPG9UCL/ockX5h1EdCCUspfTfJSrfVrs66F6RICMYl9SX42yWKt9V1J3ojh8NC71blHPpzkJ5MMktxaSvnvZ1sVAGydUsrfT3IpyaOzrgV2u1LKLUn+fpJfn3UtTJ8QiEmcTnK61vrl1ee/n5VQCOjXLyT5s1rrK7XWi0k+l+S/nHFN0Jo/L6W8LUlW/z0z43qgGaWUX0ryoSQfq7W6LQX6N8zKh49fK6X8+6zchvlkKeXOmVbFVAiBGFut9eUkL5ZS/uLqS/91kudmWBK04oUkP1dKuaWUUrJy7pmUHbbW55P80urjX0ryhzOsBZpRSvlAkgeT/NVa67lZ1wMtqLU+U2u9o9Z6d6317qwMBvjZ1etBdjghEJP6eJJHSylPJ/mZJP/7bMuB3W919N3vJ3kyyTNZ+d39qZkWBbtYKeWzSf7fJH+xlHK6lPI/JvmNJO8vpXwzKyul/MYsa4TdaJ1z75NJDif5YinlqVLKwzMtEnahdc49dqliRCUAAADA7mckEAAAAEADhEAAAAAADRACAQAAADRACAQAAADQACEQAAAAQAOEQAAAAAANEAIBAAAANEAIBAAAANCA/w/NfO0T5xf7TwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_reg, showfliers=False)\n",
    "xticks = []\n",
    "xticklabels = []\n",
    "for i in range(len(dim_set)):\n",
    "    xticks.append(int(len(methods)/2) + i * len(methods))\n",
    "    xticklabels.append(f'{dim_set[i]}')\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "72f54a1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_err, showfliers=False)\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "id": "6a01f416",
   "metadata": {},
   "outputs": [],
   "source": [
    "AN_set = [0.1, 0.3, 0.5, 0.7, 0.9]\n",
    "for an in AN_set:\n",
    "    [globals()[f\"Regret_RF_{an}\"], globals()[f\"Regret_ML_{an}\"], globals()[f\"Regret_Ridge_{an}\"],\n",
    "     globals()[f\"Regret_OLS_{an}\"], globals()[f\"Regret_SPO_{an}\"], globals()[f\"Regret_NOGD_{an}\"], \n",
    "     globals()[f\"Regret_SVMOGD_{an}\"]] = np.loadtxt(os.path.join('Additive_Noise', \"RegretFK_AN{}\".format(an)))\n",
    "    [globals()[f\"Error_RF_{an}\"], globals()[f\"Error_ML_{an}\"], globals()[f\"Error_Ridge_{an}\"],\n",
    "     globals()[f\"Error_OLS_{an}\"], globals()[f\"Error_SPO_{an}\"], globals()[f\"Error_NOGD_{an}\"],\n",
    "     globals()[f\"Error_SVMOGD_{an}\"]] = np.loadtxt(os.path.join('Additive_Noise', \"ErrorFK_AN{}\".format(an)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "id": "44c52fb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "regret = []\n",
    "error = []\n",
    "columns = []\n",
    "for an in AN_set:\n",
    "    regret = regret + [globals()[f\"Regret_RF_{an}\"], globals()[f\"Regret_Ridge_{an}\"],\n",
    "                 globals()[f\"Regret_OLS_{an}\"], globals()[f\"Regret_ML_{an}\"], globals()[f\"Regret_SPO_{an}\"], globals()[f\"Regret_NOGD_{an}\"], \n",
    "                 globals()[f\"Regret_SVMOGD_{an}\"]]\n",
    "    error = error + [globals()[f\"Error_RF_{an}\"], globals()[f\"Error_Ridge_{an}\"],\n",
    "                 globals()[f\"Error_OLS_{an}\"], globals()[f\"Error_ML_{an}\"], globals()[f\"Error_SPO_{an}\"], globals()[f\"Error_NOGD_{an}\"],\n",
    "                 globals()[f\"Error_SVMOGD_{an}\"]]\n",
    "    columns = columns + [f\"RF, {an}\", f\"Ridge, {an}\", f\"OLS, {an}\", f\"ML, {an}\", f\"SPO, {an}\", f\"NOGD, {an}\", f\"SVMOGD, {an}\"]\n",
    "data_reg = pd.DataFrame(np.array(regret).T, columns = columns)\n",
    "data_err = pd.DataFrame(np.array(error).T, columns = columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "id": "5a8c2733",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_reg, showfliers=False)\n",
    "xticks = []\n",
    "xticklabels = []\n",
    "for i in range(len(AN_set)):\n",
    "    xticks.append(int(len(methods)/2) + i * len(methods))\n",
    "    xticklabels.append(f'{AN_set[i]}')\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "id": "d3ba6a9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_err, showfliers=False)\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 500,
   "id": "f88dacff",
   "metadata": {},
   "outputs": [],
   "source": [
    "SN_set = [0.1, 0.3, 0.5, 0.7, 0.9]\n",
    "for sn in SN_set:\n",
    "    [globals()[f\"Regret_RF_{sn}\"], globals()[f\"Regret_ML_{sn}\"], globals()[f\"Regret_Ridge_{sn}\"],\n",
    "     globals()[f\"Regret_OLS_{sn}\"], globals()[f\"Regret_SPO_{sn}\"], globals()[f\"Regret_NOGD_{sn}\"], \n",
    "     globals()[f\"Regret_SVMOGD_{sn}\"]] = np.loadtxt(os.path.join('Scalar_Noise', \"RegretFK_SN{}\".format(sn)))\n",
    "    [globals()[f\"Error_RF_{sn}\"], globals()[f\"Error_ML_{sn}\"], globals()[f\"Error_Ridge_{sn}\"],\n",
    "     globals()[f\"Error_OLS_{sn}\"], globals()[f\"Error_SPO_{sn}\"], globals()[f\"Error_NOGD_{sn}\"],\n",
    "     globals()[f\"Error_SVMOGD_{sn}\"]] = np.loadtxt(os.path.join('Scalar_Noise', \"ErrorFK_SN{}\".format(sn)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 501,
   "id": "d7c3c079",
   "metadata": {},
   "outputs": [],
   "source": [
    "regret = []\n",
    "error = []\n",
    "columns = []\n",
    "for sn in SN_set:\n",
    "    regret = regret + [globals()[f\"Regret_RF_{sn}\"], globals()[f\"Regret_Ridge_{sn}\"],\n",
    "                 globals()[f\"Regret_OLS_{sn}\"], globals()[f\"Regret_ML_{sn}\"], globals()[f\"Regret_SPO_{sn}\"], globals()[f\"Regret_NOGD_{sn}\"], \n",
    "                 globals()[f\"Regret_SVMOGD_{sn}\"]]\n",
    "    error = error + [globals()[f\"Error_RF_{sn}\"], globals()[f\"Error_Ridge_{sn}\"],\n",
    "                 globals()[f\"Error_OLS_{sn}\"], globals()[f\"Error_ML_{sn}\"], globals()[f\"Error_SPO_{sn}\"], globals()[f\"Error_NOGD_{sn}\"],\n",
    "                 globals()[f\"Error_SVMOGD_{sn}\"]]\n",
    "    columns = columns + [f\"RF, {sn}\", f\"Ridge, {sn}\", f\"OLS, {sn}\", f\"ML, {sn}\", f\"SPO, {sn}\", f\"NOGD, {sn}\", f\"SVMOGD, {sn}\"]\n",
    "data_reg = pd.DataFrame(np.array(regret).T, columns = columns)\n",
    "data_err = pd.DataFrame(np.array(error).T, columns = columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 502,
   "id": "6266c0d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_reg, showfliers=False)\n",
    "xticks = []\n",
    "xticklabels = []\n",
    "for i in range(len(SN_set)):\n",
    "    xticks.append(int(len(methods)/2) + i * len(methods))\n",
    "    xticklabels.append(f'{SN_set[i]}')\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 503,
   "id": "d59070e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_err, showfliers=False)\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1e22d946",
   "metadata": {},
   "outputs": [],
   "source": [
    "degree_set = [1, 3, 5, 7]\n",
    "for deg in degree_set:\n",
    "    [globals()[f\"Regret_RF_{deg}\"], globals()[f\"Regret_ML_{deg}\"], globals()[f\"Regret_Ridge_{deg}\"],\n",
    "     globals()[f\"Regret_OLS_{deg}\"], globals()[f\"Regret_SPO_{deg}\"], globals()[f\"Regret_NOGD_{deg}\"], \n",
    "     globals()[f\"Regret_SVMOGD_{deg}\"]] = np.loadtxt(os.path.join('Degree', \"RegretFK_deg{}\".format(deg)))\n",
    "    [globals()[f\"Error_RF_{deg}\"], globals()[f\"Error_ML_{deg}\"], globals()[f\"Error_Ridge_{deg}\"],\n",
    "     globals()[f\"Error_OLS_{deg}\"], globals()[f\"Error_SPO_{deg}\"], globals()[f\"Error_NOGD_{deg}\"],\n",
    "     globals()[f\"Error_SVMOGD_{deg}\"]] = np.loadtxt(os.path.join('Degree', \"ErrorFK_deg{}\".format(deg)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1eed30f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "regret = []\n",
    "error = []\n",
    "columns = []\n",
    "for deg in degree_set:\n",
    "    regret = regret + [globals()[f\"Regret_RF_{deg}\"], globals()[f\"Regret_Ridge_{deg}\"],\n",
    "             globals()[f\"Regret_OLS_{deg}\"], globals()[f\"Regret_ML_{deg}\"], globals()[f\"Regret_SPO_{deg}\"], globals()[f\"Regret_NOGD_{deg}\"], \n",
    "             globals()[f\"Regret_SVMOGD_{deg}\"]]\n",
    "    error = error + [globals()[f\"Error_RF_{deg}\"], globals()[f\"Error_Ridge_{deg}\"],\n",
    "             globals()[f\"Error_OLS_{deg}\"], globals()[f\"Error_ML_{deg}\"], globals()[f\"Error_SPO_{deg}\"], globals()[f\"Error_NOGD_{deg}\"],\n",
    "             globals()[f\"Error_SVMOGD_{deg}\"]]\n",
    "    columns = columns + [f\"RF, {deg}\", f\"Ridge, {deg}\", f\"OLS, {deg}\", f\"ML, {deg}\", f\"SPO, {deg}\", f\"NOGD, {deg}\", f\"SVMOGD, {deg}\"]\n",
    "data_reg = pd.DataFrame(np.array(regret).T, columns = columns)\n",
    "data_err = pd.DataFrame(np.array(error).T, columns = columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "24bab7bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_reg, showfliers=False)\n",
    "xticks = []\n",
    "xticklabels = []\n",
    "for i in range(len(degree_set)):\n",
    "    xticks.append(int(len(methods)/2) + i * len(methods))\n",
    "    xticklabels.append(f'{degree_set[i]}')\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b3889a89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(20, 10))\n",
    "ax = sns.boxplot(data=data_err, showfliers=False)\n",
    "plt.setp(ax, xticks=xticks, xticklabels=xticklabels)\n",
    "boxes = ax.artists\n",
    "\n",
    "methods = ['RF', 'Ridge', 'OLS', 'ML', 'SPO', 'NOGD', 'SVMOGD']\n",
    "for i,box in enumerate(boxes):\n",
    "    for j in range(len(methods)):\n",
    "        if methods[j] in data_reg.columns[i]:\n",
    "            box.set_facecolor(sns.color_palette()[j])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c99b8570",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cvxpy as cp\n",
    "import sklearn\n",
    "import sklearn.datasets\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "import gurobipy\n",
    "import mosek\n",
    "import matplotlib.pyplot as plt\n",
    "from multiprocessing import Pool\n",
    "import time\n",
    "import os\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "# My Code\n",
    "import LearningMethod as lm\n",
    "import DataGeneration as dg\n",
    "import LinearProgramMethod as lpm\n",
    "import OnlineMethod as om\n",
    "\n",
    "# Generate Fractional Knapsack Samples\n",
    "benchmark = 1\n",
    "dim_features = 5\n",
    "dim_decision = 10\n",
    "price = np.random.rand(dim_decision)\n",
    "lower = np.amax(price)\n",
    "upper = (np.random.rand()-1)*lower + np.sum(price)\n",
    "Budget = [(upper-lower)*np.random.rand() + lower]\n",
    "Coeff_Mat = np.random.binomial(n=1, p=0.5, size = (dim_decision, dim_features))\n",
    "Theta_true = -np.concatenate((Coeff_Mat, np.zeros((dim_decision+1, dim_features))), axis=0)\n",
    "\n",
    "N = 1000\n",
    "z, c, A, b = dg.GenerateFractionalKnapsack_Margin(N_samples=N, dim_features=dim_features, dim_decision=dim_decision,\n",
    "                                                  price=price, Budget=Budget, Coeff_Mat=Coeff_Mat, margin=0.00)\n",
    "\n",
    "# Compute Optimal Solutions\n",
    "start = time.time()\n",
    "basic, nonb, solution = lpm.ComputeBasis(c=c, A=A, b=b)\n",
    "print(\"Time cost\", time.time() - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2080f977",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [26:31<00:00,  1.59s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Regret_ML = om.OnlineMarginLearning(A=A, b=b, c=c, z=z, basic=basic, nonb=nonb,\n",
    "                                    regular_const=1e-6, solved=True, solution=solution, show_figure=True, checkpoint = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ce8f54d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:04<00:00, 207.14it/s]\n",
      "  2%|█▌                                                                             | 19/1000 [00:00<00:05, 184.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time cost 1.7151317596435547\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:05<00:00, 196.46it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:04<00:00, 208.00it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [02:30<00:00,  6.65it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:04<00:00, 215.19it/s]\n",
      "  2%|█▌                                                                             | 19/1000 [00:00<00:05, 172.93it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time cost 1.711205005645752\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:05<00:00, 195.79it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:04<00:00, 208.35it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [02:33<00:00,  6.54it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:04<00:00, 212.95it/s]\n",
      "  2%|█▎                                                                             | 17/1000 [00:00<00:05, 167.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time cost 1.7656826972961426\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:05<00:00, 193.32it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:04<00:00, 203.32it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [02:33<00:00,  6.53it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2a8c0d59760>]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "total_trials = 3\n",
    "N = 1000\n",
    "Regret_OGD = np.zeros(N)\n",
    "Regret_MoM = np.zeros(N)\n",
    "Regret_Perceptron = np.zeros(N)\n",
    "for trial in range(total_trials):\n",
    "    # Generate Fractional Knapsack Samples\n",
    "    benchmark = 1\n",
    "    dim_features = 5\n",
    "    dim_decision = 10\n",
    "    price = np.random.rand(dim_decision)\n",
    "    lower = np.amax(price)\n",
    "    upper = (np.random.rand()-1)*lower + np.sum(price)\n",
    "    Budget = [(upper-lower)*np.random.rand() + lower]\n",
    "    Coeff_Mat = np.random.binomial(n=1, p=0.5, size = (dim_decision, dim_features))\n",
    "    Theta_true = -np.concatenate((Coeff_Mat, np.zeros((dim_decision+1, dim_features))), axis=0)\n",
    "    z, c, A, b = dg.GenerateFractionalKnapsack_Margin(N_samples=N, dim_features=dim_features, dim_decision=dim_decision,\n",
    "                                                      price=price, Budget=Budget, Coeff_Mat=Coeff_Mat, margin=0.00)\n",
    "\n",
    "    # Compute Optimal Solutions\n",
    "    start = time.time()\n",
    "    basic, nonb, solution = lpm.ComputeBasis(c=c, A=A, b=b)\n",
    "    print(\"Time cost\", time.time() - start)\n",
    "    \n",
    "    # Perceptron\n",
    "    Regret_tmp, _, _ = om.Perceptron(A, b, c, z, basic, nonb, solved=True, solution=solution, show_figure=False, margin=0.00)\n",
    "    Regret_Perceptron += (1/total_trials)*Regret_tmp\n",
    "    # OGD\n",
    "    Regret_OGD += (1/total_trials)*om.OGD_MarginLearning(A=A, b=b, c=c, z=z, basic=basic, nonb=nonb,\n",
    "                                                        solved=True, solution=solution, show_figure=False, step_size = 1e0, regular_const=0)\n",
    "    # MoM\n",
    "    Regret_MoM += (1/total_trials)*om.OnlineMarginLearning(A=A, b=b, c=c, z=z, basic=basic, nonb=nonb,\n",
    "                                                        regular_const=1e-6, solved=True, solution=solution, show_figure=False, checkpoint = 10)\n",
    "plt.plot(Regret_Perceptron)\n",
    "plt.plot(Regret_OGD)\n",
    "plt.plot(Regret_MoM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e9c26060",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2a8c0e8bf70>]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Regret_Perceptron = np.concatenate(([0], Regret_Perceptron))\n",
    "Regret_OGD = np.concatenate(([0], Regret_OGD))\n",
    "Regret_MoM = np.concatenate(([0], Regret_MoM))\n",
    "plt.plot(Regret_Perceptron, color='r')\n",
    "plt.plot(Regret_OGD, color='g')\n",
    "plt.plot(Regret_MoM, color='b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f44de938",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(os.path.join('Online', f\"OGD\"), Regret_OGD)\n",
    "np.savetxt(os.path.join('Online', f\"Perceptron\"), Regret_Perceptron)\n",
    "np.savetxt(os.path.join('Online', f\"MoM\"), Regret_MoM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "717654d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [02:45<00:00,  6.02it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total wrong decisions 80\n"
     ]
    }
   ],
   "source": [
    "Regret_ML = om.OnlineMarginLearning(A=A, b=b, c=c, z=z, basic=basic, nonb=nonb,\n",
    "                                    regular_const=1e-6, solved=True, solution=solution, show_figure=True, checkpoint = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "01badb27",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████| 100000/100000 [08:19<00:00, 200.14it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total wrong decisions 6538\n"
     ]
    }
   ],
   "source": [
    "Regret_Perceptron, predict_cost, reduced_cost = om.Perceptron(A, b, c, z, basic, nonb, solved=True, solution=solution, show_figure=True, margin=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "02956d1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:25<00:00, 198.69it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total wrong decisions 1741\n"
     ]
    }
   ],
   "source": [
    "Regret_Perceptron, predict_cost, reduced_cost = om.Perceptron(A, b, c, z, basic, nonb, solved=True, solution=solution, show_figure=True, margin=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3269f80d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████| 1000/1000 [00:05<00:00, 199.68it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total wrong decisions 443\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\numpy\\core\\_asarray.py:102: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  return array(a, dtype, copy=False, order=order)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Regret_Perceptron, predict_cost, reduced_cost = om.Perceptron(A, b, c, z, basic, nonb, solved=True, solution=solution, show_figure=True, margin=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "90af6c58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Regret_Perceptron, color='b', label='Perceptron')\n",
    "plt.plot(Regret_ML, color='r', label='Maximum Margin')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "16a90d32",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████| 5000/5000 [00:29<00:00, 171.21it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Regret_Perceptron, predict_cost, reduced_cost = om.Perceptron(A, b, mod_c, z, basic, nonb, solved=True, solution=solution, show_figure=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "394f5e01",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████| 5000/5000 [1:28:04<00:00,  1.06s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Regret_ML = om.OnlineMarginLearning(A=A, b=b, c=mod_c, z=z, basic=basic, nonb=nonb,\n",
    "                                    regular_const=1e-6, solved=True, solution=solution, show_figure=True, checkpoint = 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9fc0beee",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [02:59<00:00,  5.58it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Regret_ML = om.OnlineMarginLearning(A=A, b=b, c=mod_c, z=z, basic=basic, nonb=nonb,\n",
    "                                    regular_const=1e-6, solved=True, solution=solution, show_figure=True, checkpoint = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "de8bf1e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1000/1000 [02:50<00:00,  5.87it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Regret_ML = om.OnlineMarginLearning(A=A, b=b, c=mod_c, z=z, basic=basic, nonb=nonb,\n",
    "                                    regular_const=1e-4, solved=True, solution=solution, show_figure=True, checkpoint = 10)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
